From bd235707acd095fdd2b079d2992923d0d732a474 Mon Sep 17 00:00:00 2001
From: "kai.giebeler" <kai.giebeler@audiotool.com>
Date: Fri, 27 Nov 2020 01:42:37 +0100
Subject: [PATCH 001/108] add WebGL to doc_valid_idents

---
 clippy_lints/src/utils/conf.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index fc6304118d988..95f5d33fb2380 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -127,6 +127,7 @@ define_Conf! {
         "OAuth", "GraphQL",
         "OCaml",
         "OpenGL", "OpenMP", "OpenSSH", "OpenSSL", "OpenStreetMap",
+        "WebGL",
         "TensorFlow",
         "TrueType",
         "iOS", "macOS",

From 415394c3fc0e008026b3f2a37fbd57a58449b4d3 Mon Sep 17 00:00:00 2001
From: pro-grammer1 <1df0d0d3-eed4-45fc-bc60-43a85079f3f9@anonaddy.me>
Date: Tue, 1 Dec 2020 09:44:43 +0000
Subject: [PATCH 002/108] Fix false positive in write_literal and print_literal
 due to numeric literals

---
 clippy_lints/src/write.rs | 22 +++++++++++++++++-----
 1 file changed, 17 insertions(+), 5 deletions(-)

diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index ff414f748ef97..78d23e1e0ef43 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -2,7 +2,8 @@ use std::borrow::Cow;
 use std::ops::Range;
 
 use crate::utils::{snippet_with_applicability, span_lint, span_lint_and_sugg, span_lint_and_then};
-use rustc_ast::ast::{Expr, ExprKind, Item, ItemKind, MacCall, StrLit, StrStyle};
+use if_chain::if_chain;
+use rustc_ast::ast::{Expr, ExprKind, Item, ItemKind, LitKind, MacCall, StrLit, StrStyle};
 use rustc_ast::token;
 use rustc_ast::tokenstream::TokenStream;
 use rustc_errors::Applicability;
@@ -442,7 +443,12 @@ impl Write {
                 return (Some(fmtstr), None);
             };
             match &token_expr.kind {
-                ExprKind::Lit(_) => {
+                ExprKind::Lit(lit)
+                    if match lit.kind {
+                        LitKind::Int(_, _) | LitKind::Float(_, _) => false,
+                        _ => true,
+                    } =>
+                {
                     let mut all_simple = true;
                     let mut seen = false;
                     for arg in &args {
@@ -460,10 +466,16 @@ impl Write {
                         span_lint(cx, lint, token_expr.span, "literal with an empty format string");
                     }
                     idx += 1;
-                },
+                }
                 ExprKind::Assign(lhs, rhs, _) => {
-                    if let ExprKind::Lit(_) = rhs.kind {
-                        if let ExprKind::Path(_, p) = &lhs.kind {
+                    if_chain! {
+                        if let ExprKind::Lit(ref lit) = rhs.kind;
+                        if match lit.kind {
+                            LitKind::Int(_, _) | LitKind::Float(_, _) => false,
+                            _ => true,
+                        };
+                        if let ExprKind::Path(_, p) = &lhs.kind;
+                        then {
                             let mut all_simple = true;
                             let mut seen = false;
                             for arg in &args {

From 39f39d5405b7e55eb08cb927e78686a5ce7377d4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= <matthias.krueger@famsik.de>
Date: Fri, 1 Jan 2021 17:43:24 +0100
Subject: [PATCH 003/108] match_like_matches_macro: strip refs in suggestion

fixes #6503

changelog: match_like_matches_macro: strip refs in suggestion (#6503)
---
 clippy_lints/src/matches.rs                   | 10 ++-
 tests/ui/match_expr_like_matches_macro.fixed  | 47 ++++++++++
 tests/ui/match_expr_like_matches_macro.rs     | 62 ++++++++++++++
 tests/ui/match_expr_like_matches_macro.stderr | 85 ++++++++++++++++++-
 4 files changed, 202 insertions(+), 2 deletions(-)

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 04b35835c6b8e..6372cb86616ec 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1185,6 +1185,14 @@ fn find_matches_sugg(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr
             } else {
                 pat
             };
+
+            // strip potential borrows (#6503), but only if the type is a reference
+            let mut ex_new = ex;
+            if let ExprKind::AddrOf(BorrowKind::Ref, .., ex_inner) = ex.kind {
+                if let ty::Ref(..) = cx.typeck_results().expr_ty(&ex_inner).kind() {
+                    ex_new = ex_inner;
+                }
+            };
             span_lint_and_sugg(
                 cx,
                 MATCH_LIKE_MATCHES_MACRO,
@@ -1194,7 +1202,7 @@ fn find_matches_sugg(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr
                 format!(
                     "{}matches!({}, {})",
                     if b0 { "" } else { "!" },
-                    snippet_with_applicability(cx, ex.span, "..", &mut applicability),
+                    snippet_with_applicability(cx, ex_new.span, "..", &mut applicability),
                     pat_and_guard,
                 ),
                 applicability,
diff --git a/tests/ui/match_expr_like_matches_macro.fixed b/tests/ui/match_expr_like_matches_macro.fixed
index 84981a5259732..319299862a700 100644
--- a/tests/ui/match_expr_like_matches_macro.fixed
+++ b/tests/ui/match_expr_like_matches_macro.fixed
@@ -99,4 +99,51 @@ fn main() {
             _ => false,
         };
     }
+
+    {
+        // should print "z" in suggestion (#6503)
+        let z = &Some(3);
+        let _z = matches!(z, Some(3));
+    }
+
+    {
+        // this could also print "z" in suggestion..?
+        let z = Some(3);
+        let _z = matches!(&z, Some(3));
+    }
+
+    {
+        enum AnEnum {
+            X,
+            Y,
+        }
+
+        fn foo(_x: AnEnum) {}
+
+        fn main() {
+            let z = AnEnum::X;
+            // we can't remove the reference here!
+            let _ = matches!(&z, AnEnum::X);
+            foo(z);
+        }
+    }
+
+    {
+        struct S(i32);
+
+        fn fun(_val: Option<S>) {}
+        let val = Some(S(42));
+        // we need the reference here because later val is consumed by fun()
+        let _res = matches!(&val, &Some(ref _a));
+        fun(val);
+    }
+
+    {
+        struct S(i32);
+
+        fn fun(_val: Option<S>) {}
+        let val = Some(S(42));
+        let _res = matches!(&val, &Some(ref _a));
+        fun(val);
+    }
 }
diff --git a/tests/ui/match_expr_like_matches_macro.rs b/tests/ui/match_expr_like_matches_macro.rs
index 94c7c3cadacf7..2ef6cf42387f6 100644
--- a/tests/ui/match_expr_like_matches_macro.rs
+++ b/tests/ui/match_expr_like_matches_macro.rs
@@ -119,4 +119,66 @@ fn main() {
             _ => false,
         };
     }
+
+    {
+        // should print "z" in suggestion (#6503)
+        let z = &Some(3);
+        let _z = match &z {
+            Some(3) => true,
+            _ => false,
+        };
+    }
+
+    {
+        // this could also print "z" in suggestion..?
+        let z = Some(3);
+        let _z = match &z {
+            Some(3) => true,
+            _ => false,
+        };
+    }
+
+    {
+        enum AnEnum {
+            X,
+            Y,
+        }
+
+        fn foo(_x: AnEnum) {}
+
+        fn main() {
+            let z = AnEnum::X;
+            // we can't remove the reference here!
+            let _ = match &z {
+                AnEnum::X => true,
+                _ => false,
+            };
+            foo(z);
+        }
+    }
+
+    {
+        struct S(i32);
+
+        fn fun(_val: Option<S>) {}
+        let val = Some(S(42));
+        // we need the reference here because later val is consumed by fun()
+        let _res = match &val {
+            &Some(ref _a) => true,
+            _ => false,
+        };
+        fun(val);
+    }
+
+    {
+        struct S(i32);
+
+        fn fun(_val: Option<S>) {}
+        let val = Some(S(42));
+        let _res = match &val {
+            &Some(ref _a) => true,
+            _ => false,
+        };
+        fun(val);
+    }
 }
diff --git a/tests/ui/match_expr_like_matches_macro.stderr b/tests/ui/match_expr_like_matches_macro.stderr
index c52e41c788944..f27b4e9cb20b1 100644
--- a/tests/ui/match_expr_like_matches_macro.stderr
+++ b/tests/ui/match_expr_like_matches_macro.stderr
@@ -70,5 +70,88 @@ LL | |             _ => true,
 LL | |         };
    | |_________^ help: try this: `!matches!(x, E::B(_) | E::C)`
 
-error: aborting due to 7 previous errors
+error: match expression looks like `matches!` macro
+  --> $DIR/match_expr_like_matches_macro.rs:126:18
+   |
+LL |           let _z = match &z {
+   |  __________________^
+LL | |             Some(3) => true,
+LL | |             _ => false,
+LL | |         };
+   | |_________^ help: try this: `matches!(z, Some(3))`
+
+error: match expression looks like `matches!` macro
+  --> $DIR/match_expr_like_matches_macro.rs:135:18
+   |
+LL |           let _z = match &z {
+   |  __________________^
+LL | |             Some(3) => true,
+LL | |             _ => false,
+LL | |         };
+   | |_________^ help: try this: `matches!(&z, Some(3))`
+
+error: match expression looks like `matches!` macro
+  --> $DIR/match_expr_like_matches_macro.rs:152:21
+   |
+LL |               let _ = match &z {
+   |  _____________________^
+LL | |                 AnEnum::X => true,
+LL | |                 _ => false,
+LL | |             };
+   | |_____________^ help: try this: `matches!(&z, AnEnum::X)`
+
+error: match expression looks like `matches!` macro
+  --> $DIR/match_expr_like_matches_macro.rs:166:20
+   |
+LL |           let _res = match &val {
+   |  ____________________^
+LL | |             &Some(ref _a) => true,
+LL | |             _ => false,
+LL | |         };
+   | |_________^ help: try this: `matches!(&val, &Some(ref _a))`
+
+error: you don't need to add `&` to both the expression and the patterns
+  --> $DIR/match_expr_like_matches_macro.rs:166:20
+   |
+LL |           let _res = match &val {
+   |  ____________________^
+LL | |             &Some(ref _a) => true,
+LL | |             _ => false,
+LL | |         };
+   | |_________^
+   |
+   = note: `-D clippy::match-ref-pats` implied by `-D warnings`
+help: try
+   |
+LL |         let _res = match val {
+LL |             Some(ref _a) => true,
+   |
+
+error: match expression looks like `matches!` macro
+  --> $DIR/match_expr_like_matches_macro.rs:178:20
+   |
+LL |           let _res = match &val {
+   |  ____________________^
+LL | |             &Some(ref _a) => true,
+LL | |             _ => false,
+LL | |         };
+   | |_________^ help: try this: `matches!(&val, &Some(ref _a))`
+
+error: you don't need to add `&` to both the expression and the patterns
+  --> $DIR/match_expr_like_matches_macro.rs:178:20
+   |
+LL |           let _res = match &val {
+   |  ____________________^
+LL | |             &Some(ref _a) => true,
+LL | |             _ => false,
+LL | |         };
+   | |_________^
+   |
+help: try
+   |
+LL |         let _res = match val {
+LL |             Some(ref _a) => true,
+   |
+
+error: aborting due to 14 previous errors
 

From 61f3d9d46b5cbfdb56069a95e5839abe8fda9acf Mon Sep 17 00:00:00 2001
From: Javier Alvarez <javier.alvarez@allthingsembedded.net>
Date: Wed, 23 Dec 2020 12:37:37 +0100
Subject: [PATCH 004/108] Add case_sensitive_file_extensions lint

Closes #6425

Looks for ends_with methods calls with case sensitive extensions.
---
 CHANGELOG.md                                  |  1 +
 clippy_lints/Cargo.toml                       |  2 +
 ...se_sensitive_file_extension_comparisons.rs | 88 +++++++++++++++++++
 clippy_lints/src/lib.rs                       |  4 +
 ...se_sensitive_file_extension_comparisons.rs | 44 ++++++++++
 ...ensitive_file_extension_comparisons.stderr | 43 +++++++++
 6 files changed, 182 insertions(+)
 create mode 100644 clippy_lints/src/case_sensitive_file_extension_comparisons.rs
 create mode 100644 tests/ui/case_sensitive_file_extension_comparisons.rs
 create mode 100644 tests/ui/case_sensitive_file_extension_comparisons.stderr

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 64864c2e2780d..b0e9ad55b4f55 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1878,6 +1878,7 @@ Released 2018-09-13
 [`boxed_local`]: https://rust-lang.github.io/rust-clippy/master/index.html#boxed_local
 [`builtin_type_shadow`]: https://rust-lang.github.io/rust-clippy/master/index.html#builtin_type_shadow
 [`cargo_common_metadata`]: https://rust-lang.github.io/rust-clippy/master/index.html#cargo_common_metadata
+[`case_sensitive_file_extension_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#case_sensitive_file_extension_comparisons
 [`cast_lossless`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
 [`cast_possible_truncation`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_possible_truncation
 [`cast_possible_wrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_possible_wrap
diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
index a9516560a6195..38098f8a14c78 100644
--- a/clippy_lints/Cargo.toml
+++ b/clippy_lints/Cargo.toml
@@ -34,6 +34,8 @@ rustc-semver="1.1.0"
 url = { version =  "2.1.0", features = ["serde"] }
 quote = "1"
 syn = { version = "1", features = ["full"] }
+regex = "1.4"
+lazy_static = "1.4"
 
 [features]
 deny-warnings = []
diff --git a/clippy_lints/src/case_sensitive_file_extension_comparisons.rs b/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
new file mode 100644
index 0000000000000..b227e9a981a8b
--- /dev/null
+++ b/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
@@ -0,0 +1,88 @@
+use crate::utils::paths::STRING;
+use crate::utils::{match_def_path, span_lint_and_help};
+use if_chain::if_chain;
+use lazy_static::lazy_static;
+use regex::Regex;
+use rustc_ast::ast::LitKind;
+use rustc_hir::{Expr, ExprKind, PathSegment};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::{source_map::Spanned, Span};
+
+declare_clippy_lint! {
+    /// **What it does:**
+    /// Checks for calls to `ends_with` with possible file extensions
+    /// and suggests to use a case-insensitive approach instead.
+    ///
+    /// **Why is this bad?**
+    /// `ends_with` is case-sensitive and may not detect files with a valid extension.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// fn is_rust_file(filename: &str) -> bool {
+    ///     filename.ends_with(".rs")
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// fn is_rust_file(filename: &str) -> bool {
+    ///     filename.rsplit('.').next().map(|ext| ext.eq_ignore_ascii_case("rs")) == Some(true)
+    /// }
+    /// ```
+    pub CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
+    pedantic,
+    "default lint description"
+}
+
+declare_lint_pass!(CaseSensitiveFileExtensionComparisons => [CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS]);
+
+fn check_case_sensitive_file_extension_comparison(ctx: &LateContext<'_>, expr: &Expr<'_>) -> Option<Span> {
+    lazy_static! {
+        static ref RE: Regex = Regex::new(r"^\.([a-z0-9]{1,5}|[A-Z0-9]{1,5})$").unwrap();
+    }
+    if_chain! {
+        if let ExprKind::MethodCall(PathSegment { ident, .. }, _, [obj, extension, ..], span) = expr.kind;
+        if ident.as_str() == "ends_with";
+        if let ExprKind::Lit(Spanned { node: LitKind::Str(ext_literal, ..), ..}) = extension.kind;
+        if RE.is_match(&ext_literal.as_str());
+        then {
+            let mut ty = ctx.typeck_results().expr_ty(obj);
+            ty = match ty.kind() {
+                ty::Ref(_, ty, ..) => ty,
+                _ => ty
+            };
+
+            match ty.kind() {
+                ty::Str => {
+                    return Some(span);
+                },
+                ty::Adt(&ty::AdtDef { did, .. }, _) => {
+                    if match_def_path(ctx, did, &STRING) {
+                        return Some(span);
+                    }
+                },
+                _ => { return None; }
+            }
+        }
+    }
+    None
+}
+
+impl LateLintPass<'tcx> for CaseSensitiveFileExtensionComparisons {
+    fn check_expr(&mut self, ctx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+        if let Some(span) = check_case_sensitive_file_extension_comparison(ctx, expr) {
+            span_lint_and_help(
+                ctx,
+                CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
+                span,
+                "case-sensitive file extension comparison",
+                None,
+                "consider using a case-insensitive comparison instead",
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 37a56bc20c8c0..ec433acf038a3 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -170,6 +170,7 @@ mod blocks_in_if_conditions;
 mod booleans;
 mod bytecount;
 mod cargo_common_metadata;
+mod case_sensitive_file_extension_comparisons;
 mod checked_conversions;
 mod cognitive_complexity;
 mod collapsible_if;
@@ -556,6 +557,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &booleans::NONMINIMAL_BOOL,
         &bytecount::NAIVE_BYTECOUNT,
         &cargo_common_metadata::CARGO_COMMON_METADATA,
+        &case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
         &checked_conversions::CHECKED_CONVERSIONS,
         &cognitive_complexity::COGNITIVE_COMPLEXITY,
         &collapsible_if::COLLAPSIBLE_ELSE_IF,
@@ -1224,6 +1226,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box zero_sized_map_values::ZeroSizedMapValues);
     store.register_late_pass(|| box vec_init_then_push::VecInitThenPush::default());
     store.register_late_pass(move || box types::PtrAsPtr::new(msrv));
+    store.register_late_pass(|| box case_sensitive_file_extension_comparisons::CaseSensitiveFileExtensionComparisons);
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
         LintId::of(&arithmetic::FLOAT_ARITHMETIC),
@@ -1281,6 +1284,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&await_holding_invalid::AWAIT_HOLDING_LOCK),
         LintId::of(&await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
         LintId::of(&bit_mask::VERBOSE_BIT_MASK),
+        LintId::of(&case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS),
         LintId::of(&checked_conversions::CHECKED_CONVERSIONS),
         LintId::of(&copies::SAME_FUNCTIONS_IN_IF_CONDITION),
         LintId::of(&copy_iterator::COPY_ITERATOR),
diff --git a/tests/ui/case_sensitive_file_extension_comparisons.rs b/tests/ui/case_sensitive_file_extension_comparisons.rs
new file mode 100644
index 0000000000000..68719c2bc6d05
--- /dev/null
+++ b/tests/ui/case_sensitive_file_extension_comparisons.rs
@@ -0,0 +1,44 @@
+#![warn(clippy::case_sensitive_file_extension_comparisons)]
+
+use std::string::String;
+
+struct TestStruct {}
+
+impl TestStruct {
+    fn ends_with(self, arg: &str) {}
+}
+
+fn is_rust_file(filename: &str) -> bool {
+    filename.ends_with(".rs")
+}
+
+fn main() {
+    // std::string::String and &str should trigger the lint failure with .ext12
+    let _ = String::from("").ends_with(".ext12");
+    let _ = "str".ends_with(".ext12");
+
+    // The test struct should not trigger the lint failure with .ext12
+    TestStruct {}.ends_with(".ext12");
+
+    // std::string::String and &str should trigger the lint failure with .EXT12
+    let _ = String::from("").ends_with(".EXT12");
+    let _ = "str".ends_with(".EXT12");
+
+    // The test struct should not trigger the lint failure with .EXT12
+    TestStruct {}.ends_with(".EXT12");
+
+    // Should not trigger the lint failure with .eXT12
+    let _ = String::from("").ends_with(".eXT12");
+    let _ = "str".ends_with(".eXT12");
+    TestStruct {}.ends_with(".eXT12");
+
+    // Should not trigger the lint failure with .EXT123 (too long)
+    let _ = String::from("").ends_with(".EXT123");
+    let _ = "str".ends_with(".EXT123");
+    TestStruct {}.ends_with(".EXT123");
+
+    // Shouldn't fail if it doesn't start with a dot
+    let _ = String::from("").ends_with("a.ext");
+    let _ = "str".ends_with("a.extA");
+    TestStruct {}.ends_with("a.ext");
+}
diff --git a/tests/ui/case_sensitive_file_extension_comparisons.stderr b/tests/ui/case_sensitive_file_extension_comparisons.stderr
new file mode 100644
index 0000000000000..05b98169f2d17
--- /dev/null
+++ b/tests/ui/case_sensitive_file_extension_comparisons.stderr
@@ -0,0 +1,43 @@
+error: case-sensitive file extension comparison
+  --> $DIR/case_sensitive_file_extension_comparisons.rs:12:14
+   |
+LL |     filename.ends_with(".rs")
+   |              ^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::case-sensitive-file-extension-comparisons` implied by `-D warnings`
+   = help: consider using a case-insensitive comparison instead
+
+error: case-sensitive file extension comparison
+  --> $DIR/case_sensitive_file_extension_comparisons.rs:17:30
+   |
+LL |     let _ = String::from("").ends_with(".ext12");
+   |                              ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using a case-insensitive comparison instead
+
+error: case-sensitive file extension comparison
+  --> $DIR/case_sensitive_file_extension_comparisons.rs:18:19
+   |
+LL |     let _ = "str".ends_with(".ext12");
+   |                   ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using a case-insensitive comparison instead
+
+error: case-sensitive file extension comparison
+  --> $DIR/case_sensitive_file_extension_comparisons.rs:24:30
+   |
+LL |     let _ = String::from("").ends_with(".EXT12");
+   |                              ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using a case-insensitive comparison instead
+
+error: case-sensitive file extension comparison
+  --> $DIR/case_sensitive_file_extension_comparisons.rs:25:19
+   |
+LL |     let _ = "str".ends_with(".EXT12");
+   |                   ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using a case-insensitive comparison instead
+
+error: aborting due to 5 previous errors
+

From 1527fb61b9352c15d87ebcbc6f786baa2d390bcd Mon Sep 17 00:00:00 2001
From: Javier Alvarez <javier.alvarez@allthingsembedded.net>
Date: Wed, 23 Dec 2020 16:31:04 +0100
Subject: [PATCH 005/108] Fix case-sensitive extension check

---
 tests/compile-test.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index ec3af94b9ca91..2b4ecc731508e 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -44,7 +44,9 @@ fn third_party_crates() -> String {
         };
         if let Some(name) = path.file_name().and_then(OsStr::to_str) {
             for dep in CRATES {
-                if name.starts_with(&format!("lib{}-", dep)) && name.ends_with(".rlib") {
+                if name.starts_with(&format!("lib{}-", dep))
+                    && name.rsplit('.').next().map(|ext| ext.eq_ignore_ascii_case("rlib")) == Some(true)
+                {
                     if let Some(old) = crates.insert(dep, path.clone()) {
                         panic!("Found multiple rlibs for crate `{}`: `{:?}` and `{:?}", dep, old, path);
                     }

From e56973a8545d384d6dcb5271b54c90c584a58065 Mon Sep 17 00:00:00 2001
From: Javier Alvarez <javier.alvarez@allthingsembedded.net>
Date: Wed, 23 Dec 2020 16:59:17 +0100
Subject: [PATCH 006/108] Remove default lint description

This was left as default and caused a CI failure for the
case_sensitive_file_extension_comparison lint.
---
 clippy_lints/src/case_sensitive_file_extension_comparisons.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clippy_lints/src/case_sensitive_file_extension_comparisons.rs b/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
index b227e9a981a8b..d5347ce6ed756 100644
--- a/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
+++ b/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
@@ -35,7 +35,7 @@ declare_clippy_lint! {
     /// ```
     pub CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
     pedantic,
-    "default lint description"
+    "Checks for calls to ends_with with case-sensitive file extensions"
 }
 
 declare_lint_pass!(CaseSensitiveFileExtensionComparisons => [CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS]);

From 15d5ac6b2fb411370a4d116a2b3a11dc1b54fb42 Mon Sep 17 00:00:00 2001
From: Stanislav Tkach <stanislav.tkach@gmail.com>
Date: Wed, 6 Jan 2021 13:26:35 +0200
Subject: [PATCH 007/108] Remove duplication in the manual_ok_or lint example

---
 clippy_lints/src/manual_ok_or.rs | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/clippy_lints/src/manual_ok_or.rs b/clippy_lints/src/manual_ok_or.rs
index b97d97ea1a5ef..8c77e155b70ce 100644
--- a/clippy_lints/src/manual_ok_or.rs
+++ b/clippy_lints/src/manual_ok_or.rs
@@ -23,9 +23,6 @@ declare_clippy_lint! {
     /// ```rust
     /// let foo: Option<i32> = None;
     /// foo.map_or(Err("error"), |v| Ok(v));
-    ///
-    /// let foo: Option<i32> = None;
-    /// foo.map_or(Err("error"), |v| Ok(v));
     /// ```
     ///
     /// Use instead:

From 8490862cc37d7518c79d09d7911d86bfca2cea89 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 6 Jan 2021 15:14:01 -0600
Subject: [PATCH 008/108] Fix path_to_res for enum inherent items

---
 clippy_lints/src/utils/mod.rs      | 96 ++++++++++++------------------
 tests/ui-internal/invalid_paths.rs |  3 +
 2 files changed, 40 insertions(+), 59 deletions(-)

diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 8f54cad77283b..b2c9d4f8739b1 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -31,7 +31,6 @@ pub use self::hir_utils::{both, eq_expr_value, over, SpanlessEq, SpanlessHash};
 use std::borrow::Cow;
 use std::collections::hash_map::Entry;
 use std::hash::BuildHasherDefault;
-use std::mem;
 
 use if_chain::if_chain;
 use rustc_ast::ast::{self, Attribute, LitKind};
@@ -40,7 +39,7 @@ use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
-use rustc_hir::def_id::{DefId, CRATE_DEF_INDEX, LOCAL_CRATE};
+use rustc_hir::def_id::{DefId, LOCAL_CRATE};
 use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
 use rustc_hir::Node;
 use rustc_hir::{
@@ -49,6 +48,7 @@ use rustc_hir::{
 };
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, Level, Lint, LintContext};
+use rustc_middle::hir::exports::Export;
 use rustc_middle::hir::map::Map;
 use rustc_middle::ty::subst::{GenericArg, GenericArgKind};
 use rustc_middle::ty::{self, layout::IntegerExt, Ty, TyCtxt, TypeFoldable};
@@ -309,65 +309,43 @@ pub fn match_path_ast(path: &ast::Path, segments: &[&str]) -> bool {
 }
 
 /// Gets the definition associated to a path.
-pub fn path_to_res(cx: &LateContext<'_>, path: &[&str]) -> Option<def::Res> {
-    let crates = cx.tcx.crates();
-    let krate = crates
-        .iter()
-        .find(|&&krate| cx.tcx.crate_name(krate).as_str() == path[0]);
-    if let Some(krate) = krate {
-        let krate = DefId {
-            krate: *krate,
-            index: CRATE_DEF_INDEX,
-        };
-        let mut current_item = None;
-        let mut items = cx.tcx.item_children(krate);
-        let mut path_it = path.iter().skip(1).peekable();
-
-        loop {
-            let segment = match path_it.next() {
-                Some(segment) => segment,
-                None => return None,
-            };
-
-            // `get_def_path` seems to generate these empty segments for extern blocks.
-            // We can just ignore them.
-            if segment.is_empty() {
-                continue;
-            }
-
-            let result = SmallVec::<[_; 8]>::new();
-            for item in mem::replace(&mut items, cx.tcx.arena.alloc_slice(&result)).iter() {
-                if item.ident.name.as_str() == *segment {
-                    if path_it.peek().is_none() {
-                        return Some(item.res);
-                    }
-
-                    current_item = Some(item);
-                    items = cx.tcx.item_children(item.res.def_id());
-                    break;
-                }
-            }
+#[allow(clippy::shadow_unrelated)] // false positive #6563
+pub fn path_to_res(cx: &LateContext<'_>, path: &[&str]) -> Option<Res> {
+    fn item_child_by_name<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, name: &str) -> Option<&'tcx Export<HirId>> {
+        tcx.item_children(def_id)
+            .iter()
+            .find(|item| item.ident.name.as_str() == name)
+    }
 
-            // The segment isn't a child_item.
-            // Try to find it under an inherent impl.
-            if_chain! {
-                if path_it.peek().is_none();
-                if let Some(current_item) = current_item;
-                let item_def_id = current_item.res.def_id();
-                if cx.tcx.def_kind(item_def_id) == DefKind::Struct;
-                then {
-                    // Bad `find_map` suggestion. See #4193.
-                    #[allow(clippy::find_map)]
-                    return cx.tcx.inherent_impls(item_def_id).iter()
-                        .flat_map(|&impl_def_id| cx.tcx.item_children(impl_def_id))
-                        .find(|item| item.ident.name.as_str() == *segment)
-                        .map(|item| item.res);
-                }
+    let (krate, first, path) = match *path {
+        [krate, first, ref path @ ..] => (krate, first, path),
+        _ => return None,
+    };
+    let tcx = cx.tcx;
+    let crates = tcx.crates();
+    let krate = crates.iter().find(|&&num| tcx.crate_name(num).as_str() == krate)?;
+    let first = item_child_by_name(tcx, krate.as_def_id(), first)?;
+    let last = path
+        .iter()
+        .copied()
+        // `get_def_path` seems to generate these empty segments for extern blocks.
+        // We can just ignore them.
+        .filter(|segment| !segment.is_empty())
+        // for each segment, find the child item
+        .try_fold(first, |item, segment| {
+            let def_id = item.res.def_id();
+            if let Some(item) = item_child_by_name(tcx, def_id, segment) {
+                Some(item)
+            } else if matches!(item.res, Res::Def(DefKind::Enum | DefKind::Struct, _)) {
+                // it is not a child item so check inherent impl items
+                tcx.inherent_impls(def_id)
+                    .iter()
+                    .find_map(|&impl_def_id| item_child_by_name(tcx, impl_def_id, segment))
+            } else {
+                None
             }
-        }
-    } else {
-        None
-    }
+        })?;
+    Some(last.res)
 }
 
 pub fn qpath_res(cx: &LateContext<'_>, qpath: &hir::QPath<'_>, id: hir::HirId) -> Res {
diff --git a/tests/ui-internal/invalid_paths.rs b/tests/ui-internal/invalid_paths.rs
index 01e28ae5e9d35..a3b19c2e3949f 100644
--- a/tests/ui-internal/invalid_paths.rs
+++ b/tests/ui-internal/invalid_paths.rs
@@ -18,6 +18,9 @@ mod paths {
 
     // Path with bad module
     pub const BAD_MOD_PATH: [&str; 2] = ["std", "xxx"];
+
+    // Path to method on an enum inherent impl
+    pub const OPTION_IS_SOME: [&str; 4] = ["core", "option", "Option", "is_some"];
 }
 
 fn main() {}

From 8d7417d8079b7f942e3a116ede6d36dc7a219e71 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 10 Jan 2021 23:32:23 -0500
Subject: [PATCH 009/108] Add: single_match will suggest using if .. == ..
 instead of if let when applicable

---
 clippy_lints/src/matches.rs  | 79 ++++++++++++++++++++++++++++++------
 tests/ui/single_match.rs     | 43 ++++++++++++++++++++
 tests/ui/single_match.stderr | 38 ++++++++++++++++-
 3 files changed, 146 insertions(+), 14 deletions(-)

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 04b35835c6b8e..2239b519632b2 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -2,10 +2,10 @@ use crate::consts::{constant, miri_to_const, Constant};
 use crate::utils::sugg::Sugg;
 use crate::utils::usage::is_unused;
 use crate::utils::{
-    expr_block, get_arg_name, get_parent_expr, in_macro, indent_of, is_allowed, is_expn_of, is_refutable,
-    is_type_diagnostic_item, is_wild, match_qpath, match_type, match_var, meets_msrv, multispan_sugg, remove_blocks,
-    snippet, snippet_block, snippet_opt, snippet_with_applicability, span_lint_and_help, span_lint_and_note,
-    span_lint_and_sugg, span_lint_and_then,
+    expr_block, get_arg_name, get_parent_expr, implements_trait, in_macro, indent_of, is_allowed, is_expn_of,
+    is_refutable, is_type_diagnostic_item, is_wild, match_qpath, match_type, match_var, meets_msrv, multispan_sugg,
+    remove_blocks, snippet, snippet_block, snippet_opt, snippet_with_applicability, span_lint_and_help,
+    span_lint_and_note, span_lint_and_sugg, span_lint_and_then,
 };
 use crate::utils::{paths, search_same, SpanlessEq, SpanlessHash};
 use if_chain::if_chain;
@@ -717,6 +717,28 @@ fn check_single_match_single_pattern(
     }
 }
 
+fn peel_pat_refs(pat: &'a Pat<'a>) -> (&'a Pat<'a>, usize) {
+    fn peel(pat: &'a Pat<'a>, count: usize) -> (&'a Pat<'a>, usize) {
+        if let PatKind::Ref(pat, _) = pat.kind {
+            peel(pat, count + 1)
+        } else {
+            (pat, count)
+        }
+    }
+    peel(pat, 0)
+}
+
+fn peel_ty_refs(ty: Ty<'_>) -> (Ty<'_>, usize) {
+    fn peel(ty: Ty<'_>, count: usize) -> (Ty<'_>, usize) {
+        if let ty::Ref(_, ty, _) = ty.kind() {
+            peel(ty, count + 1)
+        } else {
+            (ty, count)
+        }
+    }
+    peel(ty, 0)
+}
+
 fn report_single_match_single_pattern(
     cx: &LateContext<'_>,
     ex: &Expr<'_>,
@@ -728,20 +750,51 @@ fn report_single_match_single_pattern(
     let els_str = els.map_or(String::new(), |els| {
         format!(" else {}", expr_block(cx, els, None, "..", Some(expr.span)))
     });
+
+    let (msg, sugg) = if_chain! {
+        let (pat, pat_ref_count) = peel_pat_refs(arms[0].pat);
+        if let PatKind::Path(_) | PatKind::Lit(_) = pat.kind;
+        let (ty, ty_ref_count) = peel_ty_refs(cx.typeck_results().expr_ty(ex));
+        if let Some(trait_id) = cx.tcx.lang_items().structural_peq_trait();
+        if ty.is_integral() || ty.is_char() || ty.is_str() || implements_trait(cx, ty, trait_id, &[]);
+        then {
+            // scrutinee derives PartialEq and the pattern is a constant.
+            let pat_ref_count = match pat.kind {
+                // string literals are already a reference.
+                PatKind::Lit(Expr { kind: ExprKind::Lit(lit), .. }) if lit.node.is_str() => pat_ref_count + 1,
+                _ => pat_ref_count,
+            };
+            let msg = "you seem to be trying to use match for an equality check. Consider using `if`";
+            let sugg = format!(
+                "if {} == {}{} {}{}",
+                snippet(cx, ex.span, ".."),
+                // PartialEq for different reference counts may not exist.
+                "&".repeat(ty_ref_count - pat_ref_count),
+                snippet(cx, arms[0].pat.span, ".."),
+                expr_block(cx, &arms[0].body, None, "..", Some(expr.span)),
+                els_str,
+            );
+            (msg, sugg)
+        } else {
+            let msg = "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`";
+            let sugg = format!(
+                "if let {} = {} {}{}",
+                snippet(cx, arms[0].pat.span, ".."),
+                snippet(cx, ex.span, ".."),
+                expr_block(cx, &arms[0].body, None, "..", Some(expr.span)),
+                els_str,
+            );
+            (msg, sugg)
+        }
+    };
+
     span_lint_and_sugg(
         cx,
         lint,
         expr.span,
-        "you seem to be trying to use match for destructuring a single pattern. Consider using `if \
-         let`",
+        msg,
         "try this",
-        format!(
-            "if let {} = {} {}{}",
-            snippet(cx, arms[0].pat.span, ".."),
-            snippet(cx, ex.span, ".."),
-            expr_block(cx, &arms[0].body, None, "..", Some(expr.span)),
-            els_str,
-        ),
+        sugg,
         Applicability::HasPlaceholders,
     );
 }
diff --git a/tests/ui/single_match.rs b/tests/ui/single_match.rs
index 1c55af5dfb673..02266308fba28 100644
--- a/tests/ui/single_match.rs
+++ b/tests/ui/single_match.rs
@@ -81,6 +81,49 @@ fn single_match_know_enum() {
     }
 }
 
+fn issue_173() {
+    let x = "test";
+    match x {
+        "test" => println!(),
+        _ => (),
+    }
+
+    #[derive(PartialEq, Eq)]
+    enum Foo {
+        A,
+        B,
+        C(u32),
+    }
+
+    let x = Foo::A;
+    match x {
+        Foo::A => println!(),
+        _ => (),
+    }
+
+    const FOO_C: Foo = Foo::C(0);
+    match x {
+        FOO_C => println!(),
+        _ => (),
+    }
+    enum Bar {
+        A,
+        B,
+    }
+    impl PartialEq for Bar {
+        fn eq(&self, rhs: &Self) -> bool {
+            matches!((self, rhs), (Self::A, Self::A) | (Self::B, Self::B))
+        }
+    }
+    impl Eq for Bar {}
+
+    let x = Bar::A;
+    match x {
+        Bar::A => println!(),
+        _ => (),
+    }
+}
+
 macro_rules! single_match {
     ($num:literal) => {
         match $num {
diff --git a/tests/ui/single_match.stderr b/tests/ui/single_match.stderr
index f69554d75f9bf..5eca07ab10957 100644
--- a/tests/ui/single_match.stderr
+++ b/tests/ui/single_match.stderr
@@ -65,5 +65,41 @@ LL | |         Cow::Owned(..) => (),
 LL | |     };
    | |_____^ help: try this: `if let Cow::Borrowed(..) = c { dummy() }`
 
-error: aborting due to 6 previous errors
+error: you seem to be trying to use match for an equality check. Consider using `if`
+  --> $DIR/single_match.rs:86:5
+   |
+LL | /     match x {
+LL | |         "test" => println!(),
+LL | |         _ => (),
+LL | |     }
+   | |_____^ help: try this: `if x == "test" { println!() }`
+
+error: you seem to be trying to use match for an equality check. Consider using `if`
+  --> $DIR/single_match.rs:99:5
+   |
+LL | /     match x {
+LL | |         Foo::A => println!(),
+LL | |         _ => (),
+LL | |     }
+   | |_____^ help: try this: `if x == Foo::A { println!() }`
+
+error: you seem to be trying to use match for an equality check. Consider using `if`
+  --> $DIR/single_match.rs:105:5
+   |
+LL | /     match x {
+LL | |         FOO_C => println!(),
+LL | |         _ => (),
+LL | |     }
+   | |_____^ help: try this: `if x == FOO_C { println!() }`
+
+error: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+  --> $DIR/single_match.rs:121:5
+   |
+LL | /     match x {
+LL | |         Bar::A => println!(),
+LL | |         _ => (),
+LL | |     }
+   | |_____^ help: try this: `if let Bar::A = x { println!() }`
+
+error: aborting due to 10 previous errors
 

From f2d493504cb863a30f45e8a0d5717285823f931e Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Sat, 28 Nov 2020 16:56:59 -0600
Subject: [PATCH 010/108] Similar names ignore underscore prefixed names

---
 clippy_lints/src/non_expressive_names.rs | 4 ++++
 tests/ui/similar_names.rs                | 5 +++++
 2 files changed, 9 insertions(+)

diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
index 446426b3e611f..855529378e650 100644
--- a/clippy_lints/src/non_expressive_names.rs
+++ b/clippy_lints/src/non_expressive_names.rs
@@ -199,6 +199,10 @@ impl<'a, 'tcx, 'b> SimilarNamesNameVisitor<'a, 'tcx, 'b> {
             );
             return;
         }
+        if interned_name.starts_with('_') {
+            // these bindings are typically unused or represent an ignored portion of a destructuring pattern
+            return;
+        }
         let count = interned_name.chars().count();
         if count < 3 {
             if count == 1 {
diff --git a/tests/ui/similar_names.rs b/tests/ui/similar_names.rs
index 6796b15289ecd..5981980988b19 100644
--- a/tests/ui/similar_names.rs
+++ b/tests/ui/similar_names.rs
@@ -101,3 +101,8 @@ pub(crate) struct DirSizes {
     pub(crate) numb_reg_cache_entries: u64,
     pub(crate) numb_reg_src_checkouts: u64,
 }
+
+fn ignore_underscore_prefix() {
+    let hello: ();
+    let _hello: ();
+}

From feee45c87270a4e6cf1959315e2c4528e7da4ec7 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Wed, 13 Jan 2021 11:08:12 +1300
Subject: [PATCH 011/108] Fix the ICE 6539

It happened because `zero_sized_map_values` used `layout_of` with types
from type aliases, which is essentially the same as the ICE 4968.
---
 clippy_lints/src/zero_sized_map_values.rs |  4 +++-
 tests/ui/crashes/ice-6539.rs              | 16 ++++++++++++++++
 2 files changed, 19 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/crashes/ice-6539.rs

diff --git a/clippy_lints/src/zero_sized_map_values.rs b/clippy_lints/src/zero_sized_map_values.rs
index 1d5fa8d06a996..5e9ffab7dfbca 100644
--- a/clippy_lints/src/zero_sized_map_values.rs
+++ b/clippy_lints/src/zero_sized_map_values.rs
@@ -6,7 +6,7 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_target::abi::LayoutOf as _;
 use rustc_typeck::hir_ty_to_ty;
 
-use crate::utils::{is_type_diagnostic_item, match_type, paths, span_lint_and_help};
+use crate::utils::{is_normalizable, is_type_diagnostic_item, match_type, paths, span_lint_and_help};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for maps with zero-sized value types anywhere in the code.
@@ -50,6 +50,8 @@ impl LateLintPass<'_> for ZeroSizedMapValues {
             if is_type_diagnostic_item(cx, ty, sym!(hashmap_type)) || match_type(cx, ty, &paths::BTREEMAP);
             if let Adt(_, ref substs) = ty.kind();
             let ty = substs.type_at(1);
+            // Do this to prevent `layout_of` crashing, being unable to fully normalize `ty`.
+            if is_normalizable(cx, cx.param_env, ty);
             if let Ok(layout) = cx.layout_of(ty);
             if layout.is_zst();
             then {
diff --git a/tests/ui/crashes/ice-6539.rs b/tests/ui/crashes/ice-6539.rs
new file mode 100644
index 0000000000000..ac6c3e4aba046
--- /dev/null
+++ b/tests/ui/crashes/ice-6539.rs
@@ -0,0 +1,16 @@
+// The test for the ICE 6539: https://github.com/rust-lang/rust-clippy/issues/6539.
+// The cause is that `zero_sized_map_values` used `layout_of` with types from type aliases,
+// which is essentially the same as the ICE 4968.
+// Note that only type aliases with associated types caused the crash this time,
+// not others such as trait impls.
+
+use std::collections::{BTreeMap, HashMap};
+
+pub trait Trait {
+    type Assoc;
+}
+
+type TypeAlias<T> = HashMap<(), <T as Trait>::Assoc>;
+type TypeAlias2<T> = BTreeMap<(), <T as Trait>::Assoc>;
+
+fn main() {}

From 02f99bea87d0a3fe665aa825bccdcce7a8d190e9 Mon Sep 17 00:00:00 2001
From: Daniel Smith <daniel.smith@datadoghq.com>
Date: Wed, 13 Jan 2021 16:08:15 -0500
Subject: [PATCH 012/108] Explicitly document false positives

---
 clippy_lints/src/await_holding_invalid.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index f136aa4572a87..ae64c68874454 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -18,7 +18,7 @@ declare_clippy_lint! {
     /// other solution is to ensure the mutex is unlocked before calling await,
     /// either by introducing a scope or an explicit call to Drop::drop.
     ///
-    /// **Known problems:** None.
+    /// **Known problems:** Will report false positive for explicitly dropped guards ([#6446](https://github.com/rust-lang/rust-clippy/issues/6446)).
     ///
     /// **Example:**
     ///
@@ -57,7 +57,7 @@ declare_clippy_lint! {
     /// at runtime. Holding onto a `RefCell` ref across an `await` suspension point
     /// risks panics from a mutable ref shared while other refs are outstanding.
     ///
-    /// **Known problems:** None.
+    /// **Known problems:** Will report false positive for explicitly dropped refs ([#6353](https://github.com/rust-lang/rust-clippy/issues/6353)).
     ///
     /// **Example:**
     ///

From 85edd65bf69266dd7cec2ca6d7bb6941b6f85444 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 14 Jan 2021 14:26:26 -0500
Subject: [PATCH 013/108] Address review comments

Add: attempt to remove address of expressions from the scrutinee expression before adding references to the pattern
---
 clippy_lints/src/matches.rs       | 45 +++++++++++------------------
 clippy_lints/src/utils/mod.rs     | 38 ++++++++++++++++++++++++
 tests/ui/single_match.rs          | 15 +++++++++-
 tests/ui/single_match.stderr      | 48 +++++++++++++++++++++----------
 tests/ui/single_match_else.stderr |  6 ++--
 5 files changed, 104 insertions(+), 48 deletions(-)

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 2239b519632b2..6ecd738d2f0b1 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -4,8 +4,8 @@ use crate::utils::usage::is_unused;
 use crate::utils::{
     expr_block, get_arg_name, get_parent_expr, implements_trait, in_macro, indent_of, is_allowed, is_expn_of,
     is_refutable, is_type_diagnostic_item, is_wild, match_qpath, match_type, match_var, meets_msrv, multispan_sugg,
-    remove_blocks, snippet, snippet_block, snippet_opt, snippet_with_applicability, span_lint_and_help,
-    span_lint_and_note, span_lint_and_sugg, span_lint_and_then,
+    peel_hir_pat_refs, peel_mid_ty_refs, peeln_hir_expr_refs, remove_blocks, snippet, snippet_block, snippet_opt,
+    snippet_with_applicability, span_lint_and_help, span_lint_and_note, span_lint_and_sugg, span_lint_and_then,
 };
 use crate::utils::{paths, search_same, SpanlessEq, SpanlessHash};
 use if_chain::if_chain;
@@ -717,28 +717,6 @@ fn check_single_match_single_pattern(
     }
 }
 
-fn peel_pat_refs(pat: &'a Pat<'a>) -> (&'a Pat<'a>, usize) {
-    fn peel(pat: &'a Pat<'a>, count: usize) -> (&'a Pat<'a>, usize) {
-        if let PatKind::Ref(pat, _) = pat.kind {
-            peel(pat, count + 1)
-        } else {
-            (pat, count)
-        }
-    }
-    peel(pat, 0)
-}
-
-fn peel_ty_refs(ty: Ty<'_>) -> (Ty<'_>, usize) {
-    fn peel(ty: Ty<'_>, count: usize) -> (Ty<'_>, usize) {
-        if let ty::Ref(_, ty, _) = ty.kind() {
-            peel(ty, count + 1)
-        } else {
-            (ty, count)
-        }
-    }
-    peel(ty, 0)
-}
-
 fn report_single_match_single_pattern(
     cx: &LateContext<'_>,
     ex: &Expr<'_>,
@@ -752,9 +730,9 @@ fn report_single_match_single_pattern(
     });
 
     let (msg, sugg) = if_chain! {
-        let (pat, pat_ref_count) = peel_pat_refs(arms[0].pat);
+        let (pat, pat_ref_count) = peel_hir_pat_refs(arms[0].pat);
         if let PatKind::Path(_) | PatKind::Lit(_) = pat.kind;
-        let (ty, ty_ref_count) = peel_ty_refs(cx.typeck_results().expr_ty(ex));
+        let (ty, ty_ref_count) = peel_mid_ty_refs(cx.typeck_results().expr_ty(ex));
         if let Some(trait_id) = cx.tcx.lang_items().structural_peq_trait();
         if ty.is_integral() || ty.is_char() || ty.is_str() || implements_trait(cx, ty, trait_id, &[]);
         then {
@@ -764,19 +742,28 @@ fn report_single_match_single_pattern(
                 PatKind::Lit(Expr { kind: ExprKind::Lit(lit), .. }) if lit.node.is_str() => pat_ref_count + 1,
                 _ => pat_ref_count,
             };
-            let msg = "you seem to be trying to use match for an equality check. Consider using `if`";
+            // References are only implicitly added to the pattern, so no overflow here.
+            // e.g. will work: match &Some(_) { Some(_) => () }
+            // will not: match Some(_) { &Some(_) => () }
+            let ref_count_diff = ty_ref_count - pat_ref_count;
+
+            // Try to remove address of expressions first.
+            let (ex, removed) = peeln_hir_expr_refs(ex, ref_count_diff);
+            let ref_count_diff = ref_count_diff - removed;
+
+            let msg = "you seem to be trying to use `match` for an equality check. Consider using `if`";
             let sugg = format!(
                 "if {} == {}{} {}{}",
                 snippet(cx, ex.span, ".."),
                 // PartialEq for different reference counts may not exist.
-                "&".repeat(ty_ref_count - pat_ref_count),
+                "&".repeat(ref_count_diff),
                 snippet(cx, arms[0].pat.span, ".."),
                 expr_block(cx, &arms[0].body, None, "..", Some(expr.span)),
                 els_str,
             );
             (msg, sugg)
         } else {
-            let msg = "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`";
+            let msg = "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`";
             let sugg = format!(
                 "if let {} = {} {}{}",
                 snippet(cx, arms[0].pat.span, ".."),
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 8f54cad77283b..8f8c681ecb713 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -1668,6 +1668,44 @@ where
     match_expr_list
 }
 
+/// Peels off all references on the pattern. Returns the underlying pattern and the number of
+/// references removed.
+pub fn peel_hir_pat_refs(pat: &'a Pat<'a>) -> (&'a Pat<'a>, usize) {
+    fn peel(pat: &'a Pat<'a>, count: usize) -> (&'a Pat<'a>, usize) {
+        if let PatKind::Ref(pat, _) = pat.kind {
+            peel(pat, count + 1)
+        } else {
+            (pat, count)
+        }
+    }
+    peel(pat, 0)
+}
+
+/// Peels off up to the given number of references on the expression. Returns the underlying
+/// expression and the number of references removed.
+pub fn peeln_hir_expr_refs(expr: &'a Expr<'a>, count: usize) -> (&'a Expr<'a>, usize) {
+    fn f(expr: &'a Expr<'a>, count: usize, target: usize) -> (&'a Expr<'a>, usize) {
+        match expr.kind {
+            ExprKind::AddrOf(_, _, expr) if count != target => f(expr, count + 1, target),
+            _ => (expr, count),
+        }
+    }
+    f(expr, 0, count)
+}
+
+/// Peels off all references on the type. Returns the underlying type and the number of references
+/// removed.
+pub fn peel_mid_ty_refs(ty: Ty<'_>) -> (Ty<'_>, usize) {
+    fn peel(ty: Ty<'_>, count: usize) -> (Ty<'_>, usize) {
+        if let ty::Ref(_, ty, _) = ty.kind() {
+            peel(ty, count + 1)
+        } else {
+            (ty, count)
+        }
+    }
+    peel(ty, 0)
+}
+
 #[macro_export]
 macro_rules! unwrap_cargo_metadata {
     ($cx: ident, $lint: ident, $deps: expr) => {{
diff --git a/tests/ui/single_match.rs b/tests/ui/single_match.rs
index 02266308fba28..ca884b41c4579 100644
--- a/tests/ui/single_match.rs
+++ b/tests/ui/single_match.rs
@@ -81,7 +81,8 @@ fn single_match_know_enum() {
     }
 }
 
-fn issue_173() {
+// issue #173
+fn if_suggestion() {
     let x = "test";
     match x {
         "test" => println!(),
@@ -106,6 +107,18 @@ fn issue_173() {
         FOO_C => println!(),
         _ => (),
     }
+
+    match &&x {
+        Foo::A => println!(),
+        _ => (),
+    }
+
+    let x = &x;
+    match &x {
+        Foo::A => println!(),
+        _ => (),
+    }
+
     enum Bar {
         A,
         B,
diff --git a/tests/ui/single_match.stderr b/tests/ui/single_match.stderr
index 5eca07ab10957..7ea6955b7401e 100644
--- a/tests/ui/single_match.stderr
+++ b/tests/ui/single_match.stderr
@@ -1,4 +1,4 @@
-error: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
   --> $DIR/single_match.rs:8:5
    |
 LL | /     match x {
@@ -17,7 +17,7 @@ LL |         println!("{:?}", y);
 LL |     };
    |
 
-error: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
   --> $DIR/single_match.rs:16:5
    |
 LL | /     match x {
@@ -29,7 +29,7 @@ LL | |         _ => (),
 LL | |     }
    | |_____^ help: try this: `if let Some(y) = x { println!("{:?}", y) }`
 
-error: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
   --> $DIR/single_match.rs:25:5
    |
 LL | /     match z {
@@ -38,7 +38,7 @@ LL | |         _ => {},
 LL | |     };
    | |_____^ help: try this: `if let (2..=3, 7..=9) = z { dummy() }`
 
-error: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
   --> $DIR/single_match.rs:54:5
    |
 LL | /     match x {
@@ -47,7 +47,7 @@ LL | |         None => (),
 LL | |     };
    | |_____^ help: try this: `if let Some(y) = x { dummy() }`
 
-error: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
   --> $DIR/single_match.rs:59:5
    |
 LL | /     match y {
@@ -56,7 +56,7 @@ LL | |         Err(..) => (),
 LL | |     };
    | |_____^ help: try this: `if let Ok(y) = y { dummy() }`
 
-error: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
   --> $DIR/single_match.rs:66:5
    |
 LL | /     match c {
@@ -65,8 +65,8 @@ LL | |         Cow::Owned(..) => (),
 LL | |     };
    | |_____^ help: try this: `if let Cow::Borrowed(..) = c { dummy() }`
 
-error: you seem to be trying to use match for an equality check. Consider using `if`
-  --> $DIR/single_match.rs:86:5
+error: you seem to be trying to use `match` for an equality check. Consider using `if`
+  --> $DIR/single_match.rs:87:5
    |
 LL | /     match x {
 LL | |         "test" => println!(),
@@ -74,8 +74,8 @@ LL | |         _ => (),
 LL | |     }
    | |_____^ help: try this: `if x == "test" { println!() }`
 
-error: you seem to be trying to use match for an equality check. Consider using `if`
-  --> $DIR/single_match.rs:99:5
+error: you seem to be trying to use `match` for an equality check. Consider using `if`
+  --> $DIR/single_match.rs:100:5
    |
 LL | /     match x {
 LL | |         Foo::A => println!(),
@@ -83,8 +83,8 @@ LL | |         _ => (),
 LL | |     }
    | |_____^ help: try this: `if x == Foo::A { println!() }`
 
-error: you seem to be trying to use match for an equality check. Consider using `if`
-  --> $DIR/single_match.rs:105:5
+error: you seem to be trying to use `match` for an equality check. Consider using `if`
+  --> $DIR/single_match.rs:106:5
    |
 LL | /     match x {
 LL | |         FOO_C => println!(),
@@ -92,8 +92,26 @@ LL | |         _ => (),
 LL | |     }
    | |_____^ help: try this: `if x == FOO_C { println!() }`
 
-error: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match.rs:121:5
+error: you seem to be trying to use `match` for an equality check. Consider using `if`
+  --> $DIR/single_match.rs:111:5
+   |
+LL | /     match &&x {
+LL | |         Foo::A => println!(),
+LL | |         _ => (),
+LL | |     }
+   | |_____^ help: try this: `if x == Foo::A { println!() }`
+
+error: you seem to be trying to use `match` for an equality check. Consider using `if`
+  --> $DIR/single_match.rs:117:5
+   |
+LL | /     match &x {
+LL | |         Foo::A => println!(),
+LL | |         _ => (),
+LL | |     }
+   | |_____^ help: try this: `if x == &Foo::A { println!() }`
+
+error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
+  --> $DIR/single_match.rs:134:5
    |
 LL | /     match x {
 LL | |         Bar::A => println!(),
@@ -101,5 +119,5 @@ LL | |         _ => (),
 LL | |     }
    | |_____^ help: try this: `if let Bar::A = x { println!() }`
 
-error: aborting due to 10 previous errors
+error: aborting due to 12 previous errors
 
diff --git a/tests/ui/single_match_else.stderr b/tests/ui/single_match_else.stderr
index 3a07c2ec54262..20be4fa226cf1 100644
--- a/tests/ui/single_match_else.stderr
+++ b/tests/ui/single_match_else.stderr
@@ -1,4 +1,4 @@
-error: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
   --> $DIR/single_match_else.rs:14:5
    |
 LL | /     match ExprNode::Butterflies {
@@ -19,7 +19,7 @@ LL |         None
 LL |     }
    |
 
-error: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
   --> $DIR/single_match_else.rs:70:5
    |
 LL | /     match Some(1) {
@@ -39,7 +39,7 @@ LL |         return
 LL |     }
    |
 
-error: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
   --> $DIR/single_match_else.rs:79:5
    |
 LL | /     match Some(1) {

From d72cb252f2f052a6b5794b56a0157cbd34751055 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Fri, 15 Jan 2021 09:11:31 +0900
Subject: [PATCH 014/108] Add notes of prioritization labels to doc

---
 CONTRIBUTING.md | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 4cfeaa153a01b..ed580e5605531 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -310,10 +310,19 @@ currently. Between writing new lints, fixing issues, reviewing pull requests and
 responding to issues there may not always be enough time to stay on top of it
 all.
 
-Our highest priority is fixing [crashes][l-crash] and [bugs][l-bug]. We don't
+Our highest priority is fixing [crashes][l-crash] and [bugs][l-bug], for example
+an ICE in a popular crate that many other crates depend on. We don't
 want Clippy to crash on your code and we want it to be as reliable as the
 suggestions from Rust compiler errors.
 
+We have prioritization labels and sync-blocker label like below.
+- [P-low][p-low]: Requires attention (fix/response/evaluation) by a team member but isn't urgent.
+- [P-medium][p-medium]: Should be addressed by a team member until the next sync.
+- [P-high][p-high]: Should be immediately addressed and will require a out-of-cycle sync or a backport.
+- [L-sync-blocker][l-sync-blocker]: An issue that "blocks" a sync. 
+Or rather: before the sync this should be addressed,
+e.g. by removing a lint again, so it doesn't hit beta/stable.
+
 ## Bors and Homu
 
 We use a bot powered by [Homu][homu] to help automate testing and landing of pull
@@ -327,6 +336,10 @@ commands [here][homu_instructions].
 [triage]: https://forge.rust-lang.org/release/triage-procedure.html
 [l-crash]: https://github.com/rust-lang/rust-clippy/labels/L-crash
 [l-bug]: https://github.com/rust-lang/rust-clippy/labels/L-bug
+[p-low]: https://github.com/rust-lang/rust-clippy/labels/P-low
+[p-medium]: https://github.com/rust-lang/rust-clippy/labels/P-medium
+[p-high]: https://github.com/rust-lang/rust-clippy/labels/P-high
+[l-sync-blocker]: https://github.com/rust-lang/rust-clippy/labels/L-sync-blocker
 [homu]: https://github.com/rust-lang/homu
 [homu_instructions]: https://bors.rust-lang.org/
 [homu_queue]: https://bors.rust-lang.org/queue/clippy

From 36ff2f739c62f81d5ecc1850d9f3354d15de928d Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 14 Jan 2021 22:02:04 -0500
Subject: [PATCH 015/108] Rename function

---
 clippy_lints/src/matches.rs   | 4 ++--
 clippy_lints/src/utils/mod.rs | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 6ecd738d2f0b1..02021b873695f 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -4,7 +4,7 @@ use crate::utils::usage::is_unused;
 use crate::utils::{
     expr_block, get_arg_name, get_parent_expr, implements_trait, in_macro, indent_of, is_allowed, is_expn_of,
     is_refutable, is_type_diagnostic_item, is_wild, match_qpath, match_type, match_var, meets_msrv, multispan_sugg,
-    peel_hir_pat_refs, peel_mid_ty_refs, peeln_hir_expr_refs, remove_blocks, snippet, snippet_block, snippet_opt,
+    peel_hir_pat_refs, peel_mid_ty_refs, peel_n_hir_expr_refs, remove_blocks, snippet, snippet_block, snippet_opt,
     snippet_with_applicability, span_lint_and_help, span_lint_and_note, span_lint_and_sugg, span_lint_and_then,
 };
 use crate::utils::{paths, search_same, SpanlessEq, SpanlessHash};
@@ -748,7 +748,7 @@ fn report_single_match_single_pattern(
             let ref_count_diff = ty_ref_count - pat_ref_count;
 
             // Try to remove address of expressions first.
-            let (ex, removed) = peeln_hir_expr_refs(ex, ref_count_diff);
+            let (ex, removed) = peel_n_hir_expr_refs(ex, ref_count_diff);
             let ref_count_diff = ref_count_diff - removed;
 
             let msg = "you seem to be trying to use `match` for an equality check. Consider using `if`";
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 8f8c681ecb713..f81bf088ec4c0 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -1683,7 +1683,7 @@ pub fn peel_hir_pat_refs(pat: &'a Pat<'a>) -> (&'a Pat<'a>, usize) {
 
 /// Peels off up to the given number of references on the expression. Returns the underlying
 /// expression and the number of references removed.
-pub fn peeln_hir_expr_refs(expr: &'a Expr<'a>, count: usize) -> (&'a Expr<'a>, usize) {
+pub fn peel_n_hir_expr_refs(expr: &'a Expr<'a>, count: usize) -> (&'a Expr<'a>, usize) {
     fn f(expr: &'a Expr<'a>, count: usize, target: usize) -> (&'a Expr<'a>, usize) {
         match expr.kind {
             ExprKind::AddrOf(_, _, expr) if count != target => f(expr, count + 1, target),

From 488153ff2ff678051f06a94dc4486632d788c328 Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Fri, 15 Jan 2021 10:56:44 +0100
Subject: [PATCH 016/108] Merge commit
 '953f024793dab92745fee9cd2c4dee6a60451771' into clippyup

---
 CHANGELOG.md                                  | 137 +++++++++-
 clippy_dev/src/bless.rs                       |  45 +++-
 clippy_dev/src/main.rs                        |  14 +-
 clippy_lints/src/attrs.rs                     |   2 +-
 clippy_lints/src/collapsible_if.rs            |  44 ++--
 clippy_lints/src/comparison_chain.rs          |   2 +-
 clippy_lints/src/copies.rs                    |   3 +-
 clippy_lints/src/copy_iterator.rs             |   2 +-
 clippy_lints/src/default.rs                   |   9 +-
 clippy_lints/src/derive.rs                    |   2 +-
 clippy_lints/src/empty_enum.rs                |  11 +-
 clippy_lints/src/escape.rs                    |  34 ++-
 clippy_lints/src/eta_reduction.rs             |   7 +-
 clippy_lints/src/from_over_into.rs            |   2 +-
 clippy_lints/src/if_let_mutex.rs              |   2 +-
 clippy_lints/src/inherent_impl.rs             |   2 +-
 clippy_lints/src/len_zero.rs                  |   2 +-
 clippy_lints/src/lib.rs                       |  19 ++
 clippy_lints/src/loops.rs                     |   2 +-
 clippy_lints/src/manual_async_fn.rs           |   4 +-
 clippy_lints/src/map_clone.rs                 |   2 +-
 clippy_lints/src/map_identity.rs              |   2 +-
 clippy_lints/src/methods/mod.rs               |   2 +-
 clippy_lints/src/minmax.rs                    |   4 +-
 clippy_lints/src/missing_doc.rs               |   2 +-
 clippy_lints/src/needless_bool.rs             |   4 +-
 clippy_lints/src/needless_borrow.rs           |   5 +-
 clippy_lints/src/needless_pass_by_value.rs    |   5 +-
 clippy_lints/src/needless_question_mark.rs    | 232 +++++++++++++++++
 clippy_lints/src/option_if_let_else.rs        |  10 +-
 clippy_lints/src/partialeq_ne_impl.rs         |   2 +-
 clippy_lints/src/pass_by_ref_or_value.rs      |   4 +-
 clippy_lints/src/ptr.rs                       |   4 +-
 clippy_lints/src/ref_option_ref.rs            |   2 +-
 clippy_lints/src/returns.rs                   |   5 +-
 clippy_lints/src/serde_api.rs                 |   2 +-
 clippy_lints/src/shadow.rs                    |   2 +-
 clippy_lints/src/swap.rs                      |   2 +-
 clippy_lints/src/to_string_in_display.rs      |   2 +-
 clippy_lints/src/types.rs                     | 134 ++++++++--
 clippy_lints/src/unnecessary_sort_by.rs       |   2 +-
 clippy_lints/src/unnecessary_wraps.rs         |   2 +-
 clippy_lints/src/unused_self.rs               |   2 +-
 clippy_lints/src/unwrap.rs                    |   3 +-
 clippy_lints/src/use_self.rs                  |   4 +-
 clippy_lints/src/useless_conversion.rs        |   4 +-
 clippy_lints/src/utils/attrs.rs               |   9 +-
 clippy_lints/src/utils/hir_utils.rs           |  13 +-
 clippy_lints/src/utils/internal_lints.rs      | 184 ++++++++++++--
 clippy_lints/src/utils/mod.rs                 |  35 ++-
 clippy_lints/src/utils/paths.rs               |  10 +
 .../src/utils/{sym.rs => sym_helper.rs}       |   1 +
 clippy_lints/src/utils/visitors.rs            |   2 +-
 clippy_lints/src/vec_init_then_push.rs        | 187 ++++++++++++++
 clippy_lints/src/wildcard_imports.rs          |   7 +-
 clippy_lints/src/write.rs                     |   7 +-
 doc/adding_lints.md                           |  10 +-
 doc/roadmap-2021.md                           | 235 ++++++++++++++++++
 rust-toolchain                                |   2 +-
 src/driver.rs                                 |   2 +-
 tests/compile-test.rs                         |   2 +-
 .../interning_defined_symbol.fixed            |   9 +-
 tests/ui-internal/interning_defined_symbol.rs |   3 +
 .../interning_defined_symbol.stderr           |  14 +-
 .../ui-internal/unnecessary_symbol_str.fixed  |  16 ++
 tests/ui-internal/unnecessary_symbol_str.rs   |  16 ++
 .../ui-internal/unnecessary_symbol_str.stderr |  39 +++
 tests/ui/auxiliary/macro_rules.rs             |  16 ++
 tests/ui/auxiliary/proc_macro_derive.rs       |  18 ++
 tests/ui/cast_alignment.rs                    |   4 +
 tests/ui/cast_alignment.stderr                |  14 +-
 tests/ui/clone_on_copy.fixed                  |   3 +-
 tests/ui/clone_on_copy.rs                     |   3 +-
 tests/ui/clone_on_copy.stderr                 |  10 +-
 tests/ui/collapsible_else_if.fixed            |   2 +
 tests/ui/collapsible_else_if.rs               |   2 +
 tests/ui/collapsible_else_if.stderr           |  16 +-
 tests/ui/empty_enum.rs                        |   3 +-
 tests/ui/empty_enum.stderr                    |   2 +-
 tests/ui/empty_enum_without_never_type.rs     |   7 +
 tests/ui/escape_analysis.rs                   |  20 ++
 tests/ui/escape_analysis.stderr               |  14 +-
 tests/ui/field_reassign_with_default.rs       |  25 ++
 tests/ui/field_reassign_with_default.stderr   |  50 ++--
 tests/ui/from_over_into.stderr                |   8 +-
 tests/ui/if_same_then_else2.rs                |   1 +
 tests/ui/if_same_then_else2.stderr            |  24 +-
 tests/ui/needless_question_mark.fixed         | 163 ++++++++++++
 tests/ui/needless_question_mark.rs            | 163 ++++++++++++
 tests/ui/needless_question_mark.stderr        |  88 +++++++
 tests/ui/needless_return.fixed                |  15 ++
 tests/ui/needless_return.rs                   |  15 ++
 tests/ui/ptr_as_ptr.fixed                     |  50 ++++
 tests/ui/ptr_as_ptr.rs                        |  50 ++++
 tests/ui/ptr_as_ptr.stderr                    |  46 ++++
 tests/ui/try_err.fixed                        |   2 +-
 tests/ui/try_err.rs                           |   2 +-
 tests/ui/unit_arg.rs                          |   3 +-
 tests/ui/unit_arg.stderr                      |  20 +-
 tests/ui/vec_init_then_push.rs                |  21 ++
 tests/ui/vec_init_then_push.stderr            |  34 +++
 tests/ui/wrong_self_convention.rs             |  30 ++-
 tests/ui/wrong_self_convention.stderr         |  40 +--
 103 files changed, 2328 insertions(+), 248 deletions(-)
 create mode 100644 clippy_lints/src/needless_question_mark.rs
 rename clippy_lints/src/utils/{sym.rs => sym_helper.rs} (68%)
 create mode 100644 clippy_lints/src/vec_init_then_push.rs
 create mode 100644 doc/roadmap-2021.md
 create mode 100644 tests/ui-internal/unnecessary_symbol_str.fixed
 create mode 100644 tests/ui-internal/unnecessary_symbol_str.rs
 create mode 100644 tests/ui-internal/unnecessary_symbol_str.stderr
 create mode 100644 tests/ui/empty_enum_without_never_type.rs
 create mode 100644 tests/ui/needless_question_mark.fixed
 create mode 100644 tests/ui/needless_question_mark.rs
 create mode 100644 tests/ui/needless_question_mark.stderr
 create mode 100644 tests/ui/ptr_as_ptr.fixed
 create mode 100644 tests/ui/ptr_as_ptr.rs
 create mode 100644 tests/ui/ptr_as_ptr.stderr
 create mode 100644 tests/ui/vec_init_then_push.rs
 create mode 100644 tests/ui/vec_init_then_push.stderr

diff --git a/CHANGELOG.md b/CHANGELOG.md
index de8da99cdee12..64864c2e2780d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,11 +6,138 @@ document.
 
 ## Unreleased / In Rust Nightly
 
-[b20d4c1...master](https://github.com/rust-lang/rust-clippy/compare/b20d4c1...master)
+[4911ab1...master](https://github.com/rust-lang/rust-clippy/compare/4911ab1...master)
+
+## Rust 1.50
+
+Current beta, release 2021-02-11
+
+[b20d4c1...4911ab1](https://github.com/rust-lang/rust-clippy/compare/b20d4c1...4911ab1)
+
+### New Lints
+
+* [`suspicious_operation_groupings`] [#6086](https://github.com/rust-lang/rust-clippy/pull/6086)
+* [`size_of_in_element_count`] [#6394](https://github.com/rust-lang/rust-clippy/pull/6394)
+* [`unnecessary_wraps`] [#6070](https://github.com/rust-lang/rust-clippy/pull/6070)
+* [`let_underscore_drop`] [#6305](https://github.com/rust-lang/rust-clippy/pull/6305)
+* [`collapsible_match`] [#6402](https://github.com/rust-lang/rust-clippy/pull/6402)
+* [`redundant_else`] [#6330](https://github.com/rust-lang/rust-clippy/pull/6330)
+* [`zero_sized_map_values`] [#6218](https://github.com/rust-lang/rust-clippy/pull/6218)
+* [`print_stderr`] [#6367](https://github.com/rust-lang/rust-clippy/pull/6367)
+* [`string_from_utf8_as_bytes`] [#6134](https://github.com/rust-lang/rust-clippy/pull/6134)
+
+### Moves and Deprecations
+
+* Previously deprecated [`str_to_string`] and [`string_to_string`] have been un-deprecated
+  as `restriction` lints [#6333](https://github.com/rust-lang/rust-clippy/pull/6333)
+* Deprecate [`panic_params`] lint. This is now available in rustc as `panic_fmt`
+  [#6351](https://github.com/rust-lang/rust-clippy/pull/6351)
+* Move [`map_err_ignore`] to `restriction`
+  [#6416](https://github.com/rust-lang/rust-clippy/pull/6416)
+* Move [`await_holding_refcell_ref`] to `pedantic`
+  [#6354](https://github.com/rust-lang/rust-clippy/pull/6354)
+* Move [`await_holding_lock`] to `pedantic`
+  [#6354](https://github.com/rust-lang/rust-clippy/pull/6354)
+
+### Enhancements
+
+* Add the `unreadable-literal-lint-fractions` configuration to disable
+  the `unreadable_literal` lint for fractions
+  [#6421](https://github.com/rust-lang/rust-clippy/pull/6421)
+* [`clone_on_copy`]: Now shows the type in the lint message
+  [#6443](https://github.com/rust-lang/rust-clippy/pull/6443)
+* [`redundant_pattern_matching`]: Now also lints on `std::task::Poll`
+  [#6339](https://github.com/rust-lang/rust-clippy/pull/6339)
+* [`redundant_pattern_matching`]: Additionally also lints on `std::net::IpAddr`
+  [#6377](https://github.com/rust-lang/rust-clippy/pull/6377)
+* [`search_is_some`]: Now suggests `contains` instead of `find(foo).is_some()`
+  [#6119](https://github.com/rust-lang/rust-clippy/pull/6119)
+* [`clone_double_ref`]: Now prints the reference type in the lint message
+  [#6442](https://github.com/rust-lang/rust-clippy/pull/6442)
+* [`modulo_one`]: Now also lints on -1.
+  [#6360](https://github.com/rust-lang/rust-clippy/pull/6360)
+* [`empty_loop`]: Now lints no_std crates, too
+  [#6205](https://github.com/rust-lang/rust-clippy/pull/6205)
+* [`or_fun_call`]: Now also lints when indexing `HashMap` or `BTreeMap`
+  [#6267](https://github.com/rust-lang/rust-clippy/pull/6267)
+* [`wrong_self_convention`]: Now also lints in trait definitions
+  [#6316](https://github.com/rust-lang/rust-clippy/pull/6316)
+* [`needless_borrow`]: Print the type in the lint message
+  [#6449](https://github.com/rust-lang/rust-clippy/pull/6449)
+
+[msrv_readme]: https://github.com/rust-lang/rust-clippy#specifying-the-minimum-supported-rust-version
+
+### False Positive Fixes
+
+* [`manual_range_contains`]: No longer lints in `const fn`
+  [#6382](https://github.com/rust-lang/rust-clippy/pull/6382)
+* [`unnecessary_lazy_evaluations`]: No longer lints if closure argument is used
+  [#6370](https://github.com/rust-lang/rust-clippy/pull/6370)
+* [`match_single_binding`]: Now ignores cases with `#[cfg()]` macros
+  [#6435](https://github.com/rust-lang/rust-clippy/pull/6435)
+* [`match_like_matches_macro`]: No longer lints on arms with attributes
+  [#6290](https://github.com/rust-lang/rust-clippy/pull/6290)
+* [`map_clone`]: No longer lints with deref and clone
+  [#6269](https://github.com/rust-lang/rust-clippy/pull/6269)
+* [`map_clone`]: No longer lints in the case of &mut
+  [#6301](https://github.com/rust-lang/rust-clippy/pull/6301)
+* [`needless_update`]: Now ignores `non_exhaustive` structs
+  [#6464](https://github.com/rust-lang/rust-clippy/pull/6464)
+* [`needless_collect`]: No longer lints when a collect is needed multiple times
+  [#6313](https://github.com/rust-lang/rust-clippy/pull/6313)
+* [`unnecessary_cast`] No longer lints cfg-dependent types
+  [#6369](https://github.com/rust-lang/rust-clippy/pull/6369)
+* [`declare_interior_mutable_const`] and [`borrow_interior_mutable_const`]:
+  Both now ignore enums with frozen variants
+  [#6110](https://github.com/rust-lang/rust-clippy/pull/6110)
+
+
+### Suggestion Fixes/Improvements
+
+* [`vec_box`]: Provide correct type scope suggestion
+  [#6271](https://github.com/rust-lang/rust-clippy/pull/6271)
+* [`manual_range_contains`]: Give correct suggestion when using floats
+  [#6320](https://github.com/rust-lang/rust-clippy/pull/6320)
+* [`unnecessary_lazy_evaluations`]: Don't always mark suggestion as MachineApplicable
+  [#6272](https://github.com/rust-lang/rust-clippy/pull/6272)
+* [`manual_async_fn`]: Improve suggestion formatting
+  [#6294](https://github.com/rust-lang/rust-clippy/pull/6294)
+* [`unnecessary_cast`]: Fix incorrectly formatted float literal suggestion
+  [#6362](https://github.com/rust-lang/rust-clippy/pull/6362)
+
+### ICE Fixes
+
+* Fix a crash in [`from_iter_instead_of_collect`]
+  [#6304](https://github.com/rust-lang/rust-clippy/pull/6304)
+* Fix a silent crash when parsing doc comments in [`needless_doctest_main`]
+  [#6458](https://github.com/rust-lang/rust-clippy/pull/6458)
+
+### Documentation Improvements
+
+* The lint website search has been improved ([#6477](https://github.com/rust-lang/rust-clippy/pull/6477)):
+  * Searching for lints with dashes and spaces is possible now. For example
+    `missing-errors-doc` and `missing errors doc` are now valid aliases for lint names
+  * Improved fuzzy search in lint descriptions
+* Various README improvements
+  [#6287](https://github.com/rust-lang/rust-clippy/pull/6287)
+* Add known problems to [`comparison_chain`] documentation
+  [#6390](https://github.com/rust-lang/rust-clippy/pull/6390)
+* Fix example used in [`cargo_common_metadata`]
+  [#6293](https://github.com/rust-lang/rust-clippy/pull/6293)
+* Improve [`map_clone`] documentation
+  [#6340](https://github.com/rust-lang/rust-clippy/pull/6340)
+
+### Others
+
+* You can now tell Clippy about the MSRV your project supports. Please refer to
+  the specific README section to learn more about MSRV support [here][msrv_readme]
+  [#6201](https://github.com/rust-lang/rust-clippy/pull/6201)
+* Add `--no-deps` option to avoid running on path dependencies in workspaces
+  [#6188](https://github.com/rust-lang/rust-clippy/pull/6188)
 
 ## Rust 1.49
 
-Current beta, release 2020-12-31
+Current stable, released 2020-12-31
 
 [e636b88...b20d4c1](https://github.com/rust-lang/rust-clippy/compare/e636b88...b20d4c1)
 
@@ -116,7 +243,7 @@ Current beta, release 2020-12-31
 
 ## Rust 1.48
 
-Current stable, released 2020-11-19
+Released 2020-11-19
 
 [09bd400...e636b88](https://github.com/rust-lang/rust-clippy/compare/09bd400...e636b88)
 
@@ -1769,6 +1896,7 @@ Released 2018-09-13
 [`cmp_null`]: https://rust-lang.github.io/rust-clippy/master/index.html#cmp_null
 [`cmp_owned`]: https://rust-lang.github.io/rust-clippy/master/index.html#cmp_owned
 [`cognitive_complexity`]: https://rust-lang.github.io/rust-clippy/master/index.html#cognitive_complexity
+[`collapsible_else_if`]: https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_else_if
 [`collapsible_if`]: https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_if
 [`collapsible_match`]: https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_match
 [`comparison_chain`]: https://rust-lang.github.io/rust-clippy/master/index.html#comparison_chain
@@ -1973,6 +2101,7 @@ Released 2018-09-13
 [`needless_doctest_main`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_doctest_main
 [`needless_lifetimes`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes
 [`needless_pass_by_value`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_pass_by_value
+[`needless_question_mark`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_question_mark
 [`needless_range_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_range_loop
 [`needless_return`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_return
 [`needless_update`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_update
@@ -2012,6 +2141,7 @@ Released 2018-09-13
 [`print_with_newline`]: https://rust-lang.github.io/rust-clippy/master/index.html#print_with_newline
 [`println_empty_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#println_empty_string
 [`ptr_arg`]: https://rust-lang.github.io/rust-clippy/master/index.html#ptr_arg
+[`ptr_as_ptr`]: https://rust-lang.github.io/rust-clippy/master/index.html#ptr_as_ptr
 [`ptr_eq`]: https://rust-lang.github.io/rust-clippy/master/index.html#ptr_eq
 [`ptr_offset_with_cast`]: https://rust-lang.github.io/rust-clippy/master/index.html#ptr_offset_with_cast
 [`pub_enum_variant_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#pub_enum_variant_names
@@ -2152,6 +2282,7 @@ Released 2018-09-13
 [`useless_transmute`]: https://rust-lang.github.io/rust-clippy/master/index.html#useless_transmute
 [`useless_vec`]: https://rust-lang.github.io/rust-clippy/master/index.html#useless_vec
 [`vec_box`]: https://rust-lang.github.io/rust-clippy/master/index.html#vec_box
+[`vec_init_then_push`]: https://rust-lang.github.io/rust-clippy/master/index.html#vec_init_then_push
 [`vec_resize_to_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#vec_resize_to_zero
 [`verbose_bit_mask`]: https://rust-lang.github.io/rust-clippy/master/index.html#verbose_bit_mask
 [`verbose_file_reads`]: https://rust-lang.github.io/rust-clippy/master/index.html#verbose_file_reads
diff --git a/clippy_dev/src/bless.rs b/clippy_dev/src/bless.rs
index 645098e4cfcd2..b877806946cfe 100644
--- a/clippy_dev/src/bless.rs
+++ b/clippy_dev/src/bless.rs
@@ -5,7 +5,7 @@ use std::env;
 use std::ffi::OsStr;
 use std::fs;
 use std::lazy::SyncLazy;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use walkdir::WalkDir;
 
 use crate::clippy_project_root;
@@ -16,27 +16,41 @@ pub static CARGO_TARGET_DIR: SyncLazy<PathBuf> = SyncLazy::new(|| match env::var
     None => env::current_dir().unwrap().join("target"),
 });
 
-pub fn bless() {
-    let test_dirs = [
+static CLIPPY_BUILD_TIME: SyncLazy<Option<std::time::SystemTime>> = SyncLazy::new(|| {
+    let profile = env::var("PROFILE").unwrap_or_else(|_| "debug".to_string());
+    let mut path = PathBuf::from(&**CARGO_TARGET_DIR);
+    path.push(profile);
+    path.push("cargo-clippy");
+    fs::metadata(path).ok()?.modified().ok()
+});
+
+pub fn bless(ignore_timestamp: bool) {
+    let test_suite_dirs = [
         clippy_project_root().join("tests").join("ui"),
+        clippy_project_root().join("tests").join("ui-internal"),
         clippy_project_root().join("tests").join("ui-toml"),
         clippy_project_root().join("tests").join("ui-cargo"),
     ];
-    for test_dir in &test_dirs {
-        WalkDir::new(test_dir)
+    for test_suite_dir in &test_suite_dirs {
+        WalkDir::new(test_suite_dir)
             .into_iter()
             .filter_map(Result::ok)
             .filter(|f| f.path().extension() == Some(OsStr::new("rs")))
             .for_each(|f| {
-                update_reference_file(f.path().with_extension("stdout"));
-                update_reference_file(f.path().with_extension("stderr"));
-                update_reference_file(f.path().with_extension("fixed"));
+                let test_name = f.path().strip_prefix(test_suite_dir).unwrap();
+                for &ext in &["stdout", "stderr", "fixed"] {
+                    update_reference_file(
+                        f.path().with_extension(ext),
+                        test_name.with_extension(ext),
+                        ignore_timestamp,
+                    );
+                }
             });
     }
 }
 
-fn update_reference_file(reference_file_path: PathBuf) {
-    let test_output_path = build_dir().join(PathBuf::from(reference_file_path.file_name().unwrap()));
+fn update_reference_file(reference_file_path: PathBuf, test_name: PathBuf, ignore_timestamp: bool) {
+    let test_output_path = build_dir().join(test_name);
     let relative_reference_file_path = reference_file_path.strip_prefix(clippy_project_root()).unwrap();
 
     // If compiletest did not write any changes during the test run,
@@ -45,6 +59,11 @@ fn update_reference_file(reference_file_path: PathBuf) {
         return;
     }
 
+    // If the test output was not updated since the last clippy build, it may be outdated
+    if !ignore_timestamp && !updated_since_clippy_build(&test_output_path).unwrap_or(true) {
+        return;
+    }
+
     let test_output_file = fs::read(&test_output_path).expect("Unable to read test output file");
     let reference_file = fs::read(&reference_file_path).unwrap_or_default();
 
@@ -64,6 +83,12 @@ fn update_reference_file(reference_file_path: PathBuf) {
     }
 }
 
+fn updated_since_clippy_build(path: &Path) -> Option<bool> {
+    let clippy_build_time = (*CLIPPY_BUILD_TIME)?;
+    let modified = fs::metadata(path).ok()?.modified().ok()?;
+    Some(modified >= clippy_build_time)
+}
+
 fn build_dir() -> PathBuf {
     let profile = env::var("PROFILE").unwrap_or_else(|_| "debug".to_string());
     let mut path = PathBuf::new();
diff --git a/clippy_dev/src/main.rs b/clippy_dev/src/main.rs
index 4fdae38e3ab7a..2ea56c42fafd6 100644
--- a/clippy_dev/src/main.rs
+++ b/clippy_dev/src/main.rs
@@ -7,8 +7,8 @@ fn main() {
     let matches = get_clap_config();
 
     match matches.subcommand() {
-        ("bless", Some(_)) => {
-            bless::bless();
+        ("bless", Some(matches)) => {
+            bless::bless(matches.is_present("ignore-timestamp"));
         },
         ("fmt", Some(matches)) => {
             fmt::run(matches.is_present("check"), matches.is_present("verbose"));
@@ -47,7 +47,15 @@ fn main() {
 
 fn get_clap_config<'a>() -> ArgMatches<'a> {
     App::new("Clippy developer tooling")
-        .subcommand(SubCommand::with_name("bless").about("bless the test output changes"))
+        .subcommand(
+            SubCommand::with_name("bless")
+                .about("bless the test output changes")
+                .arg(
+                    Arg::with_name("ignore-timestamp")
+                        .long("ignore-timestamp")
+                        .help("Include files updated before clippy was built"),
+                ),
+        )
         .subcommand(
             SubCommand::with_name("fmt")
                 .about("Run rustfmt on all projects and tests")
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 3edbe723922f8..9a00fc535fc5c 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -399,7 +399,7 @@ fn extract_clippy_lint(lint: &NestedMetaItem) -> Option<SymbolStr> {
         if let Some(meta_item) = lint.meta_item();
         if meta_item.path.segments.len() > 1;
         if let tool_name = meta_item.path.segments[0].ident;
-        if tool_name.as_str() == "clippy";
+        if tool_name.name == sym::clippy;
         let lint_name = meta_item.path.segments.last().unwrap().ident.name;
         then {
             return Some(lint_name.as_str());
diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs
index 42bff564de03d..93ccc76d0c9cd 100644
--- a/clippy_lints/src/collapsible_if.rs
+++ b/clippy_lints/src/collapsible_if.rs
@@ -23,9 +23,7 @@ use rustc_errors::Applicability;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for nested `if` statements which can be collapsed
-    /// by `&&`-combining their conditions and for `else { if ... }` expressions
-    /// that
-    /// can be collapsed to `else if ...`.
+    /// by `&&`-combining their conditions.
     ///
     /// **Why is this bad?** Each `if`-statement adds one level of nesting, which
     /// makes code look more complex than it really is.
@@ -40,7 +38,31 @@ declare_clippy_lint! {
     ///     }
     /// }
     ///
-    /// // or
+    /// ```
+    ///
+    /// Should be written:
+    ///
+    /// ```rust.ignore
+    /// if x && y {
+    ///     …
+    /// }
+    /// ```
+    pub COLLAPSIBLE_IF,
+    style,
+    "nested `if`s that can be collapsed (e.g., `if x { if y { ... } }`"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for collapsible `else { if ... }` expressions
+    /// that can be collapsed to `else if ...`.
+    ///
+    /// **Why is this bad?** Each `if`-statement adds one level of nesting, which
+    /// makes code look more complex than it really is.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust,ignore
     ///
     /// if x {
     ///     …
@@ -54,24 +76,18 @@ declare_clippy_lint! {
     /// Should be written:
     ///
     /// ```rust.ignore
-    /// if x && y {
-    ///     …
-    /// }
-    ///
-    /// // or
-    ///
     /// if x {
     ///     …
     /// } else if y {
     ///     …
     /// }
     /// ```
-    pub COLLAPSIBLE_IF,
+    pub COLLAPSIBLE_ELSE_IF,
     style,
-    "`if`s that can be collapsed (e.g., `if x { if y { ... } }` and `else { if x { ... } }`)"
+    "nested `else`-`if` expressions that can be collapsed (e.g., `else { if x { ... } }`)"
 }
 
-declare_lint_pass!(CollapsibleIf => [COLLAPSIBLE_IF]);
+declare_lint_pass!(CollapsibleIf => [COLLAPSIBLE_IF, COLLAPSIBLE_ELSE_IF]);
 
 impl EarlyLintPass for CollapsibleIf {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &ast::Expr) {
@@ -112,7 +128,7 @@ fn check_collapsible_maybe_if_let(cx: &EarlyContext<'_>, else_: &ast::Expr) {
             let mut applicability = Applicability::MachineApplicable;
             span_lint_and_sugg(
                 cx,
-                COLLAPSIBLE_IF,
+                COLLAPSIBLE_ELSE_IF,
                 block.span,
                 "this `else { if .. }` block can be collapsed",
                 "collapse nested if block",
diff --git a/clippy_lints/src/comparison_chain.rs b/clippy_lints/src/comparison_chain.rs
index ae1143b2c50ce..90d31dece1311 100644
--- a/clippy_lints/src/comparison_chain.rs
+++ b/clippy_lints/src/comparison_chain.rs
@@ -13,7 +13,7 @@ declare_clippy_lint! {
     /// repetitive
     ///
     /// **Known problems:** The match statement may be slower due to the compiler
-    /// not inlining the call to cmp. See issue #5354
+    /// not inlining the call to cmp. See issue [#5354](https://github.com/rust-lang/rust-clippy/issues/5354)
     ///
     /// **Example:**
     /// ```rust,ignore
diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index 6f48ffeb0e9c9..944aaafb46de5 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -112,7 +112,8 @@ impl<'tcx> LateLintPass<'tcx> for CopyAndPaste {
             if let Some(&Expr {
                 kind: ExprKind::If(_, _, Some(ref else_expr)),
                 ..
-            }) = get_parent_expr(cx, expr) {
+            }) = get_parent_expr(cx, expr)
+            {
                 if else_expr.hir_id == expr.hir_id {
                     return;
                 }
diff --git a/clippy_lints/src/copy_iterator.rs b/clippy_lints/src/copy_iterator.rs
index a7aa2cb35c1c1..48899b3389937 100644
--- a/clippy_lints/src/copy_iterator.rs
+++ b/clippy_lints/src/copy_iterator.rs
@@ -1,5 +1,5 @@
 use crate::utils::{is_copy, match_path, paths, span_lint_and_note};
-use rustc_hir::{Item, ItemKind, Impl};
+use rustc_hir::{Impl, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index b0d7c7b3baab1..f7224811e6e79 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -1,4 +1,6 @@
-use crate::utils::{any_parent_is_automatically_derived, contains_name, match_def_path, paths, qpath_res, snippet};
+use crate::utils::{
+    any_parent_is_automatically_derived, contains_name, match_def_path, paths, qpath_res, snippet_with_macro_callsite,
+};
 use crate::utils::{span_lint_and_note, span_lint_and_sugg};
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashSet;
@@ -6,6 +8,7 @@ use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::{Block, Expr, ExprKind, PatKind, QPath, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::{Ident, Symbol};
@@ -118,6 +121,8 @@ impl LateLintPass<'_> for Default {
                 // only take `let ...` statements
                 if let StmtKind::Local(local) = stmt.kind;
                 if let Some(expr) = local.init;
+                if !any_parent_is_automatically_derived(cx.tcx, expr.hir_id);
+                if !in_external_macro(cx.tcx.sess, expr.span);
                 // only take bindings to identifiers
                 if let PatKind::Binding(_, binding_id, ident, _) = local.pat.kind;
                 // only when assigning `... = Default::default()`
@@ -187,7 +192,7 @@ impl LateLintPass<'_> for Default {
                     .into_iter()
                     .map(|(field, rhs)| {
                         // extract and store the assigned value for help message
-                        let value_snippet = snippet(cx, rhs.span, "..");
+                        let value_snippet = snippet_with_macro_callsite(cx, rhs.span, "..");
                         format!("{}: {}", field, value_snippet)
                     })
                     .collect::<Vec<String>>()
diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index b55f59f021dff..b1e363663bb27 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -7,7 +7,7 @@ use if_chain::if_chain;
 use rustc_hir::def_id::DefId;
 use rustc_hir::intravisit::{walk_expr, walk_fn, walk_item, FnKind, NestedVisitorMap, Visitor};
 use rustc_hir::{
-    BlockCheckMode, BodyId, Expr, ExprKind, FnDecl, HirId, Item, ItemKind, Impl, TraitRef, UnsafeSource, Unsafety,
+    BlockCheckMode, BodyId, Expr, ExprKind, FnDecl, HirId, Impl, Item, ItemKind, TraitRef, UnsafeSource, Unsafety,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
diff --git a/clippy_lints/src/empty_enum.rs b/clippy_lints/src/empty_enum.rs
index a249117d182fa..853b3afdc3ae2 100644
--- a/clippy_lints/src/empty_enum.rs
+++ b/clippy_lints/src/empty_enum.rs
@@ -8,8 +8,12 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 declare_clippy_lint! {
     /// **What it does:** Checks for `enum`s with no variants.
     ///
+    /// As of this writing, the `never_type` is still a
+    /// nightly-only experimental API. Therefore, this lint is only triggered
+    /// if the `never_type` is enabled.
+    ///
     /// **Why is this bad?** If you want to introduce a type which
-    /// can't be instantiated, you should use `!` (the never type),
+    /// can't be instantiated, you should use `!` (the primitive type "never"),
     /// or a wrapper around it, because `!` has more extensive
     /// compiler support (type inference, etc...) and wrappers
     /// around it are the conventional way to define an uninhabited type.
@@ -40,6 +44,11 @@ declare_lint_pass!(EmptyEnum => [EMPTY_ENUM]);
 
 impl<'tcx> LateLintPass<'tcx> for EmptyEnum {
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+        // Only suggest the `never_type` if the feature is enabled
+        if !cx.tcx.features().never_type {
+            return;
+        }
+
         let did = cx.tcx.hir().local_def_id(item.hir_id);
         if let ItemKind::Enum(..) = item.kind {
             let ty = cx.tcx.type_of(did);
diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs
index 550876978129e..40e93da8dffb4 100644
--- a/clippy_lints/src/escape.rs
+++ b/clippy_lints/src/escape.rs
@@ -1,15 +1,16 @@
 use rustc_hir::intravisit;
-use rustc_hir::{self, Body, FnDecl, HirId, HirIdSet, ItemKind, Impl, Node};
+use rustc_hir::{self, AssocItemKind, Body, FnDecl, HirId, HirIdSet, Impl, ItemKind, Node};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{self, Ty};
+use rustc_middle::ty::{self, TraitRef, Ty};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
+use rustc_span::symbol::kw;
 use rustc_target::abi::LayoutOf;
 use rustc_target::spec::abi::Abi;
 use rustc_typeck::expr_use_visitor::{ConsumeMode, Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
 
-use crate::utils::span_lint;
+use crate::utils::{contains_ty, span_lint};
 
 #[derive(Copy, Clone)]
 pub struct BoxedLocal {
@@ -51,6 +52,7 @@ fn is_non_trait_box(ty: Ty<'_>) -> bool {
 struct EscapeDelegate<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
     set: HirIdSet,
+    trait_self_ty: Option<Ty<'a>>,
     too_large_for_stack: u64,
 }
 
@@ -72,19 +74,34 @@ impl<'tcx> LateLintPass<'tcx> for BoxedLocal {
             }
         }
 
-        // If the method is an impl for a trait, don't warn.
         let parent_id = cx.tcx.hir().get_parent_item(hir_id);
         let parent_node = cx.tcx.hir().find(parent_id);
 
+        let mut trait_self_ty = None;
         if let Some(Node::Item(item)) = parent_node {
+            // If the method is an impl for a trait, don't warn.
             if let ItemKind::Impl(Impl { of_trait: Some(_), .. }) = item.kind {
                 return;
             }
+
+            // find `self` ty for this trait if relevant
+            if let ItemKind::Trait(_, _, _, _, items) = item.kind {
+                for trait_item in items {
+                    if trait_item.id.hir_id == hir_id {
+                        // be sure we have `self` parameter in this function
+                        if let AssocItemKind::Fn { has_self: true } = trait_item.kind {
+                            trait_self_ty =
+                                Some(TraitRef::identity(cx.tcx, trait_item.id.hir_id.owner.to_def_id()).self_ty());
+                        }
+                    }
+                }
+            }
         }
 
         let mut v = EscapeDelegate {
             cx,
             set: HirIdSet::default(),
+            trait_self_ty,
             too_large_for_stack: self.too_large_for_stack,
         };
 
@@ -153,10 +170,17 @@ impl<'a, 'tcx> Delegate<'tcx> for EscapeDelegate<'a, 'tcx> {
                     return;
                 }
 
+                // skip if there is a `self` parameter binding to a type
+                // that contains `Self` (i.e.: `self: Box<Self>`), see #4804
+                if let Some(trait_self_ty) = self.trait_self_ty {
+                    if map.name(cmt.hir_id) == kw::SelfLower && contains_ty(cmt.place.ty(), trait_self_ty) {
+                        return;
+                    }
+                }
+
                 if is_non_trait_box(cmt.place.ty()) && !self.is_large_box(cmt.place.ty()) {
                     self.set.insert(cmt.hir_id);
                 }
-                return;
             }
         }
     }
diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 53df3abbf5437..1a722d39f730b 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -22,7 +22,7 @@ declare_clippy_lint! {
     /// **Known problems:** If creating the closure inside the closure has a side-
     /// effect then moving the closure creation out will change when that side-
     /// effect runs.
-    /// See rust-lang/rust-clippy#1439 for more details.
+    /// See [#1439](https://github.com/rust-lang/rust-clippy/issues/1439) for more details.
     ///
     /// **Example:**
     /// ```rust,ignore
@@ -45,8 +45,9 @@ declare_clippy_lint! {
     ///
     /// **Why is this bad?** It's unnecessary to create the closure.
     ///
-    /// **Known problems:** rust-lang/rust-clippy#3071, rust-lang/rust-clippy#4002,
-    /// rust-lang/rust-clippy#3942
+    /// **Known problems:** [#3071](https://github.com/rust-lang/rust-clippy/issues/3071),
+    /// [#3942](https://github.com/rust-lang/rust-clippy/issues/3942),
+    /// [#4002](https://github.com/rust-lang/rust-clippy/issues/4002)
     ///
     ///
     /// **Example:**
diff --git a/clippy_lints/src/from_over_into.rs b/clippy_lints/src/from_over_into.rs
index 1e7e5f53cc2a3..b010abda24d10 100644
--- a/clippy_lints/src/from_over_into.rs
+++ b/clippy_lints/src/from_over_into.rs
@@ -70,7 +70,7 @@ impl LateLintPass<'_> for FromOverInto {
                 span_lint_and_help(
                     cx,
                     FROM_OVER_INTO,
-                    item.span,
+                    cx.tcx.sess.source_map().guess_head_span(item.span),
                     "an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true",
                     None,
                     "consider to implement `From` instead",
diff --git a/clippy_lints/src/if_let_mutex.rs b/clippy_lints/src/if_let_mutex.rs
index 2e55094d90c6f..58511c6d57c68 100644
--- a/clippy_lints/src/if_let_mutex.rs
+++ b/clippy_lints/src/if_let_mutex.rs
@@ -145,7 +145,7 @@ impl<'tcx, 'l> ArmVisitor<'tcx, 'l> {
 fn is_mutex_lock_call<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
     if_chain! {
         if let ExprKind::MethodCall(path, _span, args, _) = &expr.kind;
-        if path.ident.to_string() == "lock";
+        if path.ident.as_str() == "lock";
         let ty = cx.typeck_results().expr_ty(&args[0]);
         if is_type_diagnostic_item(cx, ty, sym!(mutex_type));
         then {
diff --git a/clippy_lints/src/inherent_impl.rs b/clippy_lints/src/inherent_impl.rs
index e287aecb044f5..ea26c84cde16a 100644
--- a/clippy_lints/src/inherent_impl.rs
+++ b/clippy_lints/src/inherent_impl.rs
@@ -2,7 +2,7 @@
 
 use crate::utils::{in_macro, span_lint_and_then};
 use rustc_data_structures::fx::FxHashMap;
-use rustc_hir::{def_id, Crate, Item, ItemKind, Impl};
+use rustc_hir::{def_id, Crate, Impl, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::Span;
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 5474b30bdec80..e95caf6a35f90 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -3,7 +3,7 @@ use rustc_ast::ast::LitKind;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
-use rustc_hir::{AssocItemKind, BinOpKind, Expr, ExprKind, ImplItemRef, Item, ItemKind, Impl, TraitItemRef};
+use rustc_hir::{AssocItemKind, BinOpKind, Expr, ExprKind, Impl, ImplItemRef, Item, ItemKind, TraitItemRef};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 35b057d7b6a41..f12994c7a605e 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -271,6 +271,7 @@ mod needless_borrow;
 mod needless_borrowed_ref;
 mod needless_continue;
 mod needless_pass_by_value;
+mod needless_question_mark;
 mod needless_update;
 mod neg_cmp_op_on_partial_ord;
 mod neg_multiply;
@@ -341,6 +342,7 @@ mod unwrap_in_result;
 mod use_self;
 mod useless_conversion;
 mod vec;
+mod vec_init_then_push;
 mod vec_resize_to_zero;
 mod verbose_file_reads;
 mod wildcard_dependencies;
@@ -524,6 +526,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &utils::internal_lints::OUTER_EXPN_EXPN_DATA,
         #[cfg(feature = "internal-lints")]
         &utils::internal_lints::PRODUCE_ICE,
+        #[cfg(feature = "internal-lints")]
+        &utils::internal_lints::UNNECESSARY_SYMBOL_STR,
         &approx_const::APPROX_CONSTANT,
         &arithmetic::FLOAT_ARITHMETIC,
         &arithmetic::INTEGER_ARITHMETIC,
@@ -556,6 +560,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &cargo_common_metadata::CARGO_COMMON_METADATA,
         &checked_conversions::CHECKED_CONVERSIONS,
         &cognitive_complexity::COGNITIVE_COMPLEXITY,
+        &collapsible_if::COLLAPSIBLE_ELSE_IF,
         &collapsible_if::COLLAPSIBLE_IF,
         &collapsible_match::COLLAPSIBLE_MATCH,
         &comparison_chain::COMPARISON_CHAIN,
@@ -799,6 +804,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE,
         &needless_continue::NEEDLESS_CONTINUE,
         &needless_pass_by_value::NEEDLESS_PASS_BY_VALUE,
+        &needless_question_mark::NEEDLESS_QUESTION_MARK,
         &needless_update::NEEDLESS_UPDATE,
         &neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD,
         &neg_multiply::NEG_MULTIPLY,
@@ -908,6 +914,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &types::LET_UNIT_VALUE,
         &types::LINKEDLIST,
         &types::OPTION_OPTION,
+        &types::PTR_AS_PTR,
         &types::RC_BUFFER,
         &types::REDUNDANT_ALLOCATION,
         &types::TYPE_COMPLEXITY,
@@ -935,6 +942,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &use_self::USE_SELF,
         &useless_conversion::USELESS_CONVERSION,
         &vec::USELESS_VEC,
+        &vec_init_then_push::VEC_INIT_THEN_PUSH,
         &vec_resize_to_zero::VEC_RESIZE_TO_ZERO,
         &verbose_file_reads::VERBOSE_FILE_READS,
         &wildcard_dependencies::WILDCARD_DEPENDENCIES,
@@ -1019,6 +1027,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || box from_over_into::FromOverInto::new(msrv));
     store.register_late_pass(move || box use_self::UseSelf::new(msrv));
     store.register_late_pass(move || box missing_const_for_fn::MissingConstForFn::new(msrv));
+    store.register_late_pass(move || box needless_question_mark::NeedlessQuestionMark::new(msrv));
 
     store.register_late_pass(|| box size_of_in_element_count::SizeOfInElementCount);
     store.register_late_pass(|| box map_clone::MapClone);
@@ -1215,6 +1224,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box strings::StrToString);
     store.register_late_pass(|| box strings::StringToString);
     store.register_late_pass(|| box zero_sized_map_values::ZeroSizedMapValues);
+    store.register_late_pass(|| box vec_init_then_push::VecInitThenPush::default());
+    store.register_late_pass(move || box types::PtrAsPtr::new(msrv));
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
         LintId::of(&arithmetic::FLOAT_ARITHMETIC),
@@ -1341,6 +1352,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&types::LET_UNIT_VALUE),
         LintId::of(&types::LINKEDLIST),
         LintId::of(&types::OPTION_OPTION),
+        LintId::of(&types::PTR_AS_PTR),
         LintId::of(&unicode::NON_ASCII_LITERAL),
         LintId::of(&unicode::UNICODE_NOT_NFC),
         LintId::of(&unnested_or_patterns::UNNESTED_OR_PATTERNS),
@@ -1362,6 +1374,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM),
         LintId::of(&utils::internal_lints::OUTER_EXPN_EXPN_DATA),
         LintId::of(&utils::internal_lints::PRODUCE_ICE),
+        LintId::of(&utils::internal_lints::UNNECESSARY_SYMBOL_STR),
     ]);
 
     store.register_group(true, "clippy::all", Some("clippy"), vec![
@@ -1384,6 +1397,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&booleans::LOGIC_BUG),
         LintId::of(&booleans::NONMINIMAL_BOOL),
         LintId::of(&bytecount::NAIVE_BYTECOUNT),
+        LintId::of(&collapsible_if::COLLAPSIBLE_ELSE_IF),
         LintId::of(&collapsible_if::COLLAPSIBLE_IF),
         LintId::of(&collapsible_match::COLLAPSIBLE_MATCH),
         LintId::of(&comparison_chain::COMPARISON_CHAIN),
@@ -1545,6 +1559,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&needless_bool::BOOL_COMPARISON),
         LintId::of(&needless_bool::NEEDLESS_BOOL),
         LintId::of(&needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
+        LintId::of(&needless_question_mark::NEEDLESS_QUESTION_MARK),
         LintId::of(&needless_update::NEEDLESS_UPDATE),
         LintId::of(&neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD),
         LintId::of(&neg_multiply::NEG_MULTIPLY),
@@ -1636,6 +1651,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&unwrap::UNNECESSARY_UNWRAP),
         LintId::of(&useless_conversion::USELESS_CONVERSION),
         LintId::of(&vec::USELESS_VEC),
+        LintId::of(&vec_init_then_push::VEC_INIT_THEN_PUSH),
         LintId::of(&vec_resize_to_zero::VEC_RESIZE_TO_ZERO),
         LintId::of(&write::PRINTLN_EMPTY_STRING),
         LintId::of(&write::PRINT_LITERAL),
@@ -1653,6 +1669,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&attrs::UNKNOWN_CLIPPY_LINTS),
         LintId::of(&blacklisted_name::BLACKLISTED_NAME),
         LintId::of(&blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
+        LintId::of(&collapsible_if::COLLAPSIBLE_ELSE_IF),
         LintId::of(&collapsible_if::COLLAPSIBLE_IF),
         LintId::of(&collapsible_match::COLLAPSIBLE_MATCH),
         LintId::of(&comparison_chain::COMPARISON_CHAIN),
@@ -1803,6 +1820,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&needless_bool::BOOL_COMPARISON),
         LintId::of(&needless_bool::NEEDLESS_BOOL),
         LintId::of(&needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
+        LintId::of(&needless_question_mark::NEEDLESS_QUESTION_MARK),
         LintId::of(&needless_update::NEEDLESS_UPDATE),
         LintId::of(&neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD),
         LintId::of(&no_effect::NO_EFFECT),
@@ -1935,6 +1953,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&types::BOX_VEC),
         LintId::of(&types::REDUNDANT_ALLOCATION),
         LintId::of(&vec::USELESS_VEC),
+        LintId::of(&vec_init_then_push::VEC_INIT_THEN_PUSH),
     ]);
 
     store.register_group(true, "clippy::cargo", Some("clippy_cargo"), vec![
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 281964ee5e8f3..1c5ab2874b048 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -218,7 +218,7 @@ declare_clippy_lint! {
     /// **Why is this bad?** The `while let` loop is usually shorter and more
     /// readable.
     ///
-    /// **Known problems:** Sometimes the wrong binding is displayed (#383).
+    /// **Known problems:** Sometimes the wrong binding is displayed ([#383](https://github.com/rust-lang/rust-clippy/issues/383)).
     ///
     /// **Example:**
     /// ```rust,no_run
diff --git a/clippy_lints/src/manual_async_fn.rs b/clippy_lints/src/manual_async_fn.rs
index 29439e52c48e1..89f5b2ff31137 100644
--- a/clippy_lints/src/manual_async_fn.rs
+++ b/clippy_lints/src/manual_async_fn.rs
@@ -9,7 +9,7 @@ use rustc_hir::{
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::Span;
+use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
     /// **What it does:** It checks for manual implementations of `async` functions.
@@ -137,7 +137,7 @@ fn future_output_ty<'tcx>(trait_ref: &'tcx TraitRef<'tcx>) -> Option<&'tcx Ty<'t
         if let Some(args) = segment.args;
         if args.bindings.len() == 1;
         let binding = &args.bindings[0];
-        if binding.ident.as_str() == "Output";
+        if binding.ident.name == sym::Output;
         if let TypeBindingKind::Equality{ty: output} = binding.kind;
         then {
             return Some(output)
diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs
index 220240acb7aa9..1818836d5d5e8 100644
--- a/clippy_lints/src/map_clone.rs
+++ b/clippy_lints/src/map_clone.rs
@@ -53,7 +53,7 @@ impl<'tcx> LateLintPass<'tcx> for MapClone {
         if_chain! {
             if let hir::ExprKind::MethodCall(ref method, _, ref args, _) = e.kind;
             if args.len() == 2;
-            if method.ident.as_str() == "map";
+            if method.ident.name == sym::map;
             let ty = cx.typeck_results().expr_ty(&args[0]);
             if is_type_diagnostic_item(cx, ty, sym::option_type) || match_trait_method(cx, e, &paths::ITERATOR);
             if let hir::ExprKind::Closure(_, _, body_id, _, _) = args[1].kind;
diff --git a/clippy_lints/src/map_identity.rs b/clippy_lints/src/map_identity.rs
index 6b782385a38d2..9f9c108a85a05 100644
--- a/clippy_lints/src/map_identity.rs
+++ b/clippy_lints/src/map_identity.rs
@@ -63,7 +63,7 @@ impl<'tcx> LateLintPass<'tcx> for MapIdentity {
 fn get_map_argument<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<&'a [Expr<'a>]> {
     if_chain! {
         if let ExprKind::MethodCall(ref method, _, ref args, _) = expr.kind;
-        if args.len() == 2 && method.ident.as_str() == "map";
+        if args.len() == 2 && method.ident.name == sym::map;
         let caller_ty = cx.typeck_results().expr_ty(&args[0]);
         if match_trait_method(cx, expr, &paths::ITERATOR)
             || is_type_diagnostic_item(cx, caller_ty, sym::result_type)
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 6e8102790a594..79aec928d298b 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3096,7 +3096,7 @@ fn lint_flat_map_identity<'tcx>(
             if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = body.value.kind;
 
             if path.segments.len() == 1;
-            if path.segments[0].ident.as_str() == binding_ident.as_str();
+            if path.segments[0].ident.name == binding_ident.name;
 
             then {
                 apply_lint("called `flat_map(|x| x)` on an `Iterator`");
diff --git a/clippy_lints/src/minmax.rs b/clippy_lints/src/minmax.rs
index 004dd50a31be8..8d0c3b8e0fe89 100644
--- a/clippy_lints/src/minmax.rs
+++ b/clippy_lints/src/minmax.rs
@@ -89,9 +89,9 @@ fn min_max<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<(MinMax, Cons
                 if let [obj, _] = args;
                 if cx.typeck_results().expr_ty(obj).is_floating_point() || match_trait_method(cx, expr, &paths::ORD);
                 then {
-                    if path.ident.as_str() == sym!(max).as_str() {
+                    if path.ident.name == sym!(max) {
                         fetch_const(cx, args, MinMax::Max)
-                    } else if path.ident.as_str() == sym!(min).as_str() {
+                    } else if path.ident.name == sym!(min) {
                         fetch_const(cx, args, MinMax::Min)
                     } else {
                         None
diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs
index 27f1074a0dd8a..0e49eaab43685 100644
--- a/clippy_lints/src/missing_doc.rs
+++ b/clippy_lints/src/missing_doc.rs
@@ -63,7 +63,7 @@ impl MissingDoc {
             if let Some(meta) = list.get(0);
             if let Some(name) = meta.ident();
             then {
-                name.as_str() == "include"
+                name.name == sym::include
             } else {
                 false
             }
diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index 6b9a37b525201..d795f12645794 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -3,9 +3,7 @@
 //! This lint is **warn** by default
 
 use crate::utils::sugg::Sugg;
-use crate::utils::{
-    is_expn_of, parent_node_is_if_expr, snippet_with_applicability, span_lint, span_lint_and_sugg,
-};
+use crate::utils::{is_expn_of, parent_node_is_if_expr, snippet_with_applicability, span_lint, span_lint_and_sugg};
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Block, Expr, ExprKind, StmtKind, UnOp};
diff --git a/clippy_lints/src/needless_borrow.rs b/clippy_lints/src/needless_borrow.rs
index bff53eb8ccada..f1c06692e30d9 100644
--- a/clippy_lints/src/needless_borrow.rs
+++ b/clippy_lints/src/needless_borrow.rs
@@ -2,7 +2,7 @@
 //!
 //! This lint is **warn** by default
 
-use crate::utils::{snippet_opt, span_lint_and_then};
+use crate::utils::{is_automatically_derived, snippet_opt, span_lint_and_then};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BindingAnnotation, BorrowKind, Expr, ExprKind, HirId, Item, Mutability, Pat, PatKind};
@@ -10,7 +10,6 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_middle::ty::adjustment::{Adjust, Adjustment};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::sym;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for address of operations (`&`) that are going to
@@ -116,7 +115,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBorrow {
     }
 
     fn check_item(&mut self, _: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        if item.attrs.iter().any(|a| a.has_name(sym::automatically_derived)) {
+        if is_automatically_derived(item.attrs) {
             debug_assert!(self.derived_item.is_none());
             self.derived_item = Some(item.hir_id);
         }
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index a435f86bfd8d5..c8f89f8046c85 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -8,11 +8,12 @@ use rustc_ast::ast::Attribute;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::{Applicability, DiagnosticBuilder};
 use rustc_hir::intravisit::FnKind;
-use rustc_hir::{BindingAnnotation, Body, FnDecl, GenericArg, HirId, ItemKind, Impl, Node, PatKind, QPath, TyKind};
+use rustc_hir::{BindingAnnotation, Body, FnDecl, GenericArg, HirId, Impl, ItemKind, Node, PatKind, QPath, TyKind};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, TypeFoldable};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::kw;
 use rustc_span::{sym, Span};
 use rustc_target::spec::abi::Abi;
 use rustc_trait_selection::traits;
@@ -153,7 +154,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
             // Ignore `self`s.
             if idx == 0 {
                 if let PatKind::Binding(.., ident, _) = arg.pat.kind {
-                    if ident.as_str() == "self" {
+                    if ident.name == kw::SelfLower {
                         continue;
                     }
                 }
diff --git a/clippy_lints/src/needless_question_mark.rs b/clippy_lints/src/needless_question_mark.rs
new file mode 100644
index 0000000000000..9e9b79ee1cf08
--- /dev/null
+++ b/clippy_lints/src/needless_question_mark.rs
@@ -0,0 +1,232 @@
+use rustc_errors::Applicability;
+use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
+use rustc_hir::{Body, Expr, ExprKind, LangItem, MatchSource, QPath};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::ty::DefIdTree;
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::sym;
+
+use crate::utils;
+use if_chain::if_chain;
+
+declare_clippy_lint! {
+    /// **What it does:**
+    /// Suggests alternatives for useless applications of `?` in terminating expressions
+    ///
+    /// **Why is this bad?** There's no reason to use `?` to short-circuit when execution of the body will end there anyway.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// struct TO {
+    ///     magic: Option<usize>,
+    /// }
+    ///
+    /// fn f(to: TO) -> Option<usize> {
+    ///     Some(to.magic?)
+    /// }
+    ///
+    /// struct TR {
+    ///     magic: Result<usize, bool>,
+    /// }
+    ///
+    /// fn g(tr: Result<TR, bool>) -> Result<usize, bool> {
+    ///     tr.and_then(|t| Ok(t.magic?))
+    /// }
+    ///
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// struct TO {
+    ///     magic: Option<usize>,
+    /// }
+    ///
+    /// fn f(to: TO) -> Option<usize> {
+    ///    to.magic
+    /// }
+    ///
+    /// struct TR {
+    ///     magic: Result<usize, bool>,
+    /// }
+    ///
+    /// fn g(tr: Result<TR, bool>) -> Result<usize, bool> {
+    ///     tr.and_then(|t| t.magic)
+    /// }
+    /// ```
+    pub NEEDLESS_QUESTION_MARK,
+    complexity,
+    "Suggest `value.inner_option` instead of `Some(value.inner_option?)`. The same goes for `Result<T, E>`."
+}
+
+const NEEDLESS_QUESTION_MARK_RESULT_MSRV: RustcVersion = RustcVersion::new(1, 13, 0);
+const NEEDLESS_QUESTION_MARK_OPTION_MSRV: RustcVersion = RustcVersion::new(1, 22, 0);
+
+pub struct NeedlessQuestionMark {
+    msrv: Option<RustcVersion>,
+}
+
+impl NeedlessQuestionMark {
+    #[must_use]
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        Self { msrv }
+    }
+}
+
+impl_lint_pass!(NeedlessQuestionMark => [NEEDLESS_QUESTION_MARK]);
+
+#[derive(Debug)]
+enum SomeOkCall<'a> {
+    SomeCall(&'a Expr<'a>, &'a Expr<'a>),
+    OkCall(&'a Expr<'a>, &'a Expr<'a>),
+}
+
+impl LateLintPass<'_> for NeedlessQuestionMark {
+    /*
+     * The question mark operator is compatible with both Result<T, E> and Option<T>,
+     * from Rust 1.13 and 1.22 respectively.
+     */
+
+    /*
+     * What do we match:
+     * Expressions that look like this:
+     * Some(option?), Ok(result?)
+     *
+     * Where do we match:
+     *      Last expression of a body
+     *      Return statement
+     *      A body's value (single line closure)
+     *
+     * What do we not match:
+     *      Implicit calls to `from(..)` on the error value
+     */
+
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'_ Expr<'_>) {
+        let e = match &expr.kind {
+            ExprKind::Ret(Some(e)) => e,
+            _ => return,
+        };
+
+        if let Some(ok_some_call) = is_some_or_ok_call(self, cx, e) {
+            emit_lint(cx, &ok_some_call);
+        }
+    }
+
+    fn check_body(&mut self, cx: &LateContext<'_>, body: &'_ Body<'_>) {
+        // Function / Closure block
+        let expr_opt = if let ExprKind::Block(block, _) = &body.value.kind {
+            block.expr
+        } else {
+            // Single line closure
+            Some(&body.value)
+        };
+
+        if_chain! {
+            if let Some(expr) = expr_opt;
+            if let Some(ok_some_call) = is_some_or_ok_call(self, cx, expr);
+            then {
+                emit_lint(cx, &ok_some_call);
+            }
+        };
+    }
+
+    extract_msrv_attr!(LateContext);
+}
+
+fn emit_lint(cx: &LateContext<'_>, expr: &SomeOkCall<'_>) {
+    let (entire_expr, inner_expr) = match expr {
+        SomeOkCall::OkCall(outer, inner) | SomeOkCall::SomeCall(outer, inner) => (outer, inner),
+    };
+
+    utils::span_lint_and_sugg(
+        cx,
+        NEEDLESS_QUESTION_MARK,
+        entire_expr.span,
+        "Question mark operator is useless here",
+        "try",
+        format!("{}", utils::snippet(cx, inner_expr.span, r#""...""#)),
+        Applicability::MachineApplicable,
+    );
+}
+
+fn is_some_or_ok_call<'a>(
+    nqml: &NeedlessQuestionMark,
+    cx: &'a LateContext<'_>,
+    expr: &'a Expr<'_>,
+) -> Option<SomeOkCall<'a>> {
+    if_chain! {
+        // Check outer expression matches CALL_IDENT(ARGUMENT) format
+        if let ExprKind::Call(path, args) = &expr.kind;
+        if let ExprKind::Path(QPath::Resolved(None, path)) = &path.kind;
+        if is_some_ctor(cx, path.res) || is_ok_ctor(cx, path.res);
+
+        // Extract inner expression from ARGUMENT
+        if let ExprKind::Match(inner_expr_with_q, _, MatchSource::TryDesugar) = &args[0].kind;
+        if let ExprKind::Call(called, args) = &inner_expr_with_q.kind;
+        if args.len() == 1;
+
+        if let ExprKind::Path(QPath::LangItem(LangItem::TryIntoResult, _)) = &called.kind;
+        then {
+            // Extract inner expr type from match argument generated by
+            // question mark operator
+            let inner_expr = &args[0];
+
+            let inner_ty = cx.typeck_results().expr_ty(inner_expr);
+            let outer_ty = cx.typeck_results().expr_ty(expr);
+
+            // Check if outer and inner type are Option
+            let outer_is_some = utils::is_type_diagnostic_item(cx, outer_ty, sym::option_type);
+            let inner_is_some = utils::is_type_diagnostic_item(cx, inner_ty, sym::option_type);
+
+            // Check for Option MSRV
+            let meets_option_msrv = utils::meets_msrv(nqml.msrv.as_ref(), &NEEDLESS_QUESTION_MARK_OPTION_MSRV);
+            if outer_is_some && inner_is_some && meets_option_msrv {
+                return Some(SomeOkCall::SomeCall(expr, inner_expr));
+            }
+
+            // Check if outer and inner type are Result
+            let outer_is_result = utils::is_type_diagnostic_item(cx, outer_ty, sym::result_type);
+            let inner_is_result = utils::is_type_diagnostic_item(cx, inner_ty, sym::result_type);
+
+            // Additional check: if the error type of the Result can be converted
+            // via the From trait, then don't match
+            let does_not_call_from = !has_implicit_error_from(cx, expr, inner_expr);
+
+            // Must meet Result MSRV
+            let meets_result_msrv = utils::meets_msrv(nqml.msrv.as_ref(), &NEEDLESS_QUESTION_MARK_RESULT_MSRV);
+            if outer_is_result && inner_is_result && does_not_call_from && meets_result_msrv {
+                return Some(SomeOkCall::OkCall(expr, inner_expr));
+            }
+        }
+    }
+
+    None
+}
+
+fn has_implicit_error_from(cx: &LateContext<'_>, entire_expr: &Expr<'_>, inner_result_expr: &Expr<'_>) -> bool {
+    return cx.typeck_results().expr_ty(entire_expr) != cx.typeck_results().expr_ty(inner_result_expr);
+}
+
+fn is_ok_ctor(cx: &LateContext<'_>, res: Res) -> bool {
+    if let Some(ok_id) = cx.tcx.lang_items().result_ok_variant() {
+        if let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Fn), id) = res {
+            if let Some(variant_id) = cx.tcx.parent(id) {
+                return variant_id == ok_id;
+            }
+        }
+    }
+    false
+}
+
+fn is_some_ctor(cx: &LateContext<'_>, res: Res) -> bool {
+    if let Some(some_id) = cx.tcx.lang_items().option_some_variant() {
+        if let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Fn), id) = res {
+            if let Some(variant_id) = cx.tcx.parent(id) {
+                return variant_id == some_id;
+            }
+        }
+    }
+    false
+}
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 391f893ef35ff..7bdf975ffd446 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -66,7 +66,7 @@ declare_lint_pass!(OptionIfLetElse => [OPTION_IF_LET_ELSE]);
 /// Returns true iff the given expression is the result of calling `Result::ok`
 fn is_result_ok(cx: &LateContext<'_>, expr: &'_ Expr<'_>) -> bool {
     if let ExprKind::MethodCall(ref path, _, &[ref receiver], _) = &expr.kind {
-        path.ident.name.to_ident_string() == "ok"
+        path.ident.name.as_str() == "ok"
             && is_type_diagnostic_item(cx, &cx.typeck_results().expr_ty(&receiver), sym::result_type)
     } else {
         false
@@ -110,7 +110,7 @@ fn extract_body_from_arm<'a>(arm: &'a Arm<'a>) -> Option<&'a Expr<'a>> {
 fn should_wrap_in_braces(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     utils::get_enclosing_block(cx, expr.hir_id).map_or(false, |parent| {
         let mut should_wrap = false;
-        
+
         if let Some(Expr {
             kind:
                 ExprKind::Match(
@@ -124,7 +124,11 @@ fn should_wrap_in_braces(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
         }) = parent.expr
         {
             should_wrap = expr.hir_id == arms[1].body.hir_id;
-        } else if let Some(Expr { kind: ExprKind::If(_, _, Some(else_clause)), .. }) = parent.expr {
+        } else if let Some(Expr {
+            kind: ExprKind::If(_, _, Some(else_clause)),
+            ..
+        }) = parent.expr
+        {
             should_wrap = expr.hir_id == else_clause.hir_id;
         }
 
diff --git a/clippy_lints/src/partialeq_ne_impl.rs b/clippy_lints/src/partialeq_ne_impl.rs
index 04b6e5d58478b..ed314937ce8be 100644
--- a/clippy_lints/src/partialeq_ne_impl.rs
+++ b/clippy_lints/src/partialeq_ne_impl.rs
@@ -1,6 +1,6 @@
 use crate::utils::{is_automatically_derived, span_lint_hir};
 use if_chain::if_chain;
-use rustc_hir::{Item, ItemKind, Impl};
+use rustc_hir::{Impl, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
index 7814065e31a1a..d96a9b025f089 100644
--- a/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -6,7 +6,7 @@ use rustc_ast::attr;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::intravisit::FnKind;
-use rustc_hir::{BindingAnnotation, Body, FnDecl, HirId, ItemKind, MutTy, Mutability, Node, PatKind, Impl};
+use rustc_hir::{BindingAnnotation, Body, FnDecl, HirId, Impl, ItemKind, MutTy, Mutability, Node, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -63,7 +63,7 @@ declare_clippy_lint! {
     ///
     /// **Why is this bad?** Arguments passed by value might result in an unnecessary
     /// shallow copy, taking up more space in the stack and requiring a call to
-    /// `memcpy`, which which can be expensive.
+    /// `memcpy`, which can be expensive.
     ///
     /// **Example:**
     ///
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index b832add009f86..c6329a1381c90 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -8,8 +8,8 @@ use crate::utils::{
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{
-    BinOpKind, BodyId, Expr, ExprKind, FnDecl, FnRetTy, GenericArg, HirId, ImplItem, ImplItemKind, Item, ItemKind, Impl,
-    Lifetime, MutTy, Mutability, Node, PathSegment, QPath, TraitFn, TraitItem, TraitItemKind, Ty, TyKind,
+    BinOpKind, BodyId, Expr, ExprKind, FnDecl, FnRetTy, GenericArg, HirId, Impl, ImplItem, ImplItemKind, Item,
+    ItemKind, Lifetime, MutTy, Mutability, Node, PathSegment, QPath, TraitFn, TraitItem, TraitItemKind, Ty, TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
diff --git a/clippy_lints/src/ref_option_ref.rs b/clippy_lints/src/ref_option_ref.rs
index 803ebada54b79..8cd6692ce03a0 100644
--- a/clippy_lints/src/ref_option_ref.rs
+++ b/clippy_lints/src/ref_option_ref.rs
@@ -13,7 +13,7 @@ declare_clippy_lint! {
     /// **Why is this bad?** Since `&` is Copy, it's useless to have a
     /// reference on `Option<&T>`.
     ///
-    /// **Known problems:** It may be irrevelent to use this lint on
+    /// **Known problems:** It may be irrelevant to use this lint on
     /// public API code as it will make a breaking change to apply it.
     ///
     /// **Example:**
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 35827e027aab8..63548d8fdb438 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -202,7 +202,7 @@ fn check_final_expr<'tcx>(
                     check_final_expr(cx, &arm.body, Some(arm.body.span), RetReplacement::Block);
                 }
             },
-            | MatchSource::IfLetDesugar {
+            MatchSource::IfLetDesugar {
                 contains_else_clause: true,
             } => {
                 if let ExprKind::Block(ref ifblock, _) = arms[0].body.kind {
@@ -217,6 +217,9 @@ fn check_final_expr<'tcx>(
 }
 
 fn emit_return_lint(cx: &LateContext<'_>, ret_span: Span, inner_span: Option<Span>, replacement: RetReplacement) {
+    if ret_span.from_expansion() {
+        return;
+    }
     match inner_span {
         Some(inner_span) => {
             if in_external_macro(cx.tcx.sess, inner_span) || inner_span.from_expansion() {
diff --git a/clippy_lints/src/serde_api.rs b/clippy_lints/src/serde_api.rs
index ca4fd9f35597f..44e739725c820 100644
--- a/clippy_lints/src/serde_api.rs
+++ b/clippy_lints/src/serde_api.rs
@@ -1,5 +1,5 @@
 use crate::utils::{get_trait_def_id, paths, span_lint};
-use rustc_hir::{Item, ItemKind, Impl};
+use rustc_hir::{Impl, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index f2f3dfa09a7d4..24da056770c9d 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -396,5 +396,5 @@ fn is_self_shadow(name: Symbol, expr: &Expr<'_>) -> bool {
 }
 
 fn path_eq_name(name: Symbol, path: &Path<'_>) -> bool {
-    !path.is_global() && path.segments.len() == 1 && path.segments[0].ident.as_str() == name.as_str()
+    !path.is_global() && path.segments.len() == 1 && path.segments[0].ident.name == name
 }
diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index 386987eb181ea..699fd51ccc194 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -91,7 +91,7 @@ fn check_manual_swap(cx: &LateContext<'_>, block: &Block<'_>) {
             if let ExprKind::Path(QPath::Resolved(None, ref rhs2)) = rhs2.kind;
             if rhs2.segments.len() == 1;
 
-            if ident.as_str() == rhs2.segments[0].ident.as_str();
+            if ident.name == rhs2.segments[0].ident.name;
             if eq_expr_value(cx, tmp_init, lhs1);
             if eq_expr_value(cx, rhs1, lhs2);
             then {
diff --git a/clippy_lints/src/to_string_in_display.rs b/clippy_lints/src/to_string_in_display.rs
index 675eaf4277a43..c53727ba16004 100644
--- a/clippy_lints/src/to_string_in_display.rs
+++ b/clippy_lints/src/to_string_in_display.rs
@@ -1,7 +1,7 @@
 use crate::utils::{match_def_path, match_trait_method, paths, qpath_res, span_lint};
 use if_chain::if_chain;
 use rustc_hir::def::Res;
-use rustc_hir::{Expr, ExprKind, HirId, ImplItem, ImplItemKind, Item, ItemKind, Impl};
+use rustc_hir::{Expr, ExprKind, HirId, Impl, ImplItem, ImplItemKind, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 2696c5e781abc..3b5a83d2a0bec 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -8,7 +8,6 @@ use if_chain::if_chain;
 use rustc_ast::{FloatTy, IntTy, LitFloatType, LitIntType, LitKind, UintTy};
 use rustc_errors::{Applicability, DiagnosticBuilder};
 use rustc_hir as hir;
-use rustc_hir::def::Res;
 use rustc_hir::intravisit::{walk_body, walk_expr, walk_ty, FnKind, NestedVisitorMap, Visitor};
 use rustc_hir::{
     BinOpKind, Block, Body, Expr, ExprKind, FnDecl, FnRetTy, FnSig, GenericArg, GenericBounds, GenericParamKind, HirId,
@@ -19,7 +18,8 @@ use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::TypeFoldable;
-use rustc_middle::ty::{self, InferTy, Ty, TyCtxt, TyS, TypeckResults};
+use rustc_middle::ty::{self, InferTy, Ty, TyCtxt, TyS, TypeAndMut, TypeckResults};
+use rustc_semver::RustcVersion;
 use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
 use rustc_span::hygiene::{ExpnKind, MacroKind};
 use rustc_span::source_map::Span;
@@ -30,11 +30,13 @@ use rustc_typeck::hir_ty_to_ty;
 
 use crate::consts::{constant, Constant};
 use crate::utils::paths;
+use crate::utils::sugg::Sugg;
 use crate::utils::{
-    clip, comparisons, differing_macro_contexts, higher, in_constant, indent_of, int_bits, is_type_diagnostic_item,
-    last_path_segment, match_def_path, match_path, method_chain_args, multispan_sugg, numeric_literal::NumericLiteral,
-    qpath_res, reindent_multiline, sext, snippet, snippet_opt, snippet_with_applicability, snippet_with_macro_callsite,
-    span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, unsext,
+    clip, comparisons, differing_macro_contexts, higher, in_constant, indent_of, int_bits, is_hir_ty_cfg_dependant,
+    is_type_diagnostic_item, last_path_segment, match_def_path, match_path, meets_msrv, method_chain_args,
+    multispan_sugg, numeric_literal::NumericLiteral, qpath_res, reindent_multiline, sext, snippet, snippet_opt,
+    snippet_with_applicability, snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg,
+    span_lint_and_then, unsext,
 };
 
 declare_clippy_lint! {
@@ -73,7 +75,7 @@ declare_clippy_lint! {
     /// **Why is this bad?** `Vec` already keeps its contents in a separate area on
     /// the heap. So if you `Box` its contents, you just add another level of indirection.
     ///
-    /// **Known problems:** Vec<Box<T: Sized>> makes sense if T is a large type (see #3530,
+    /// **Known problems:** Vec<Box<T: Sized>> makes sense if T is a large type (see [#3530](https://github.com/rust-lang/rust-clippy/issues/3530),
     /// 1st comment).
     ///
     /// **Example:**
@@ -1279,8 +1281,8 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for casts from a less-strictly-aligned pointer to a
-    /// more-strictly-aligned pointer
+    /// **What it does:** Checks for casts, using `as` or `pointer::cast`,
+    /// from a less-strictly-aligned pointer to a more-strictly-aligned pointer
     ///
     /// **Why is this bad?** Dereferencing the resulting pointer may be undefined
     /// behavior.
@@ -1293,6 +1295,9 @@ declare_clippy_lint! {
     /// ```rust
     /// let _ = (&1u8 as *const u8) as *const u16;
     /// let _ = (&mut 1u8 as *mut u8) as *mut u16;
+    ///
+    /// (&1u8 as *const u8).cast::<u16>();
+    /// (&mut 1u8 as *mut u8).cast::<u16>();
     /// ```
     pub CAST_PTR_ALIGNMENT,
     pedantic,
@@ -1634,12 +1639,8 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
             return;
         }
         if let ExprKind::Cast(ref ex, cast_to) = expr.kind {
-            if let TyKind::Path(QPath::Resolved(_, path)) = cast_to.kind {
-                if let Res::Def(_, def_id) = path.res {
-                    if cx.tcx.has_attr(def_id, sym::cfg) || cx.tcx.has_attr(def_id, sym::cfg_attr) {
-                        return;
-                    }
-                }
+            if is_hir_ty_cfg_dependant(cx, cast_to) {
+                return;
             }
             let (cast_from, cast_to) = (cx.typeck_results().expr_ty(ex), cx.typeck_results().expr_ty(expr));
             lint_fn_to_numeric_cast(cx, expr, ex, cast_from, cast_to);
@@ -1689,6 +1690,19 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
             }
 
             lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
+        } else if let ExprKind::MethodCall(method_path, _, args, _) = expr.kind {
+            if_chain! {
+            if method_path.ident.name == sym!(cast);
+            if let Some(generic_args) = method_path.args;
+            if let [GenericArg::Type(cast_to)] = generic_args.args;
+            // There probably is no obvious reason to do this, just to be consistent with `as` cases.
+            if !is_hir_ty_cfg_dependant(cx, cast_to);
+            then {
+                let (cast_from, cast_to) =
+                    (cx.typeck_results().expr_ty(&args[0]), cx.typeck_results().expr_ty(expr));
+                lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
+            }
+            }
         }
     }
 }
@@ -2873,3 +2887,93 @@ impl<'tcx> LateLintPass<'tcx> for RefToMut {
         }
     }
 }
+
+const PTR_AS_PTR_MSRV: RustcVersion = RustcVersion::new(1, 38, 0);
+
+declare_clippy_lint! {
+    /// **What it does:**
+    /// Checks for `as` casts between raw pointers without changing its mutability,
+    /// namely `*const T` to `*const U` and `*mut T` to `*mut U`.
+    ///
+    /// **Why is this bad?**
+    /// Though `as` casts between raw pointers is not terrible, `pointer::cast` is safer because
+    /// it cannot accidentally change the pointer's mutability nor cast the pointer to other types like `usize`.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// 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
+    /// let ptr: *const u32 = &42_u32;
+    /// let mut_ptr: *mut u32 = &mut 42_u32;
+    /// let _ = ptr.cast::<i32>();
+    /// let _ = mut_ptr.cast::<i32>();
+    /// ```
+    pub PTR_AS_PTR,
+    pedantic,
+    "casting using `as` from and to raw pointers that doesn't change its mutability, where `pointer::cast` could take the place of `as`"
+}
+
+pub struct PtrAsPtr {
+    msrv: Option<RustcVersion>,
+}
+
+impl PtrAsPtr {
+    #[must_use]
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        Self { msrv }
+    }
+}
+
+impl_lint_pass!(PtrAsPtr => [PTR_AS_PTR]);
+
+impl<'tcx> LateLintPass<'tcx> for PtrAsPtr {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if !meets_msrv(self.msrv.as_ref(), &PTR_AS_PTR_MSRV) {
+            return;
+        }
+
+        if expr.span.from_expansion() {
+            return;
+        }
+
+        if_chain! {
+            if let ExprKind::Cast(cast_expr, cast_to_hir_ty) = expr.kind;
+            let (cast_from, cast_to) = (cx.typeck_results().expr_ty(cast_expr), cx.typeck_results().expr_ty(expr));
+            if let ty::RawPtr(TypeAndMut { mutbl: from_mutbl, .. }) = cast_from.kind();
+            if let ty::RawPtr(TypeAndMut { ty: to_pointee_ty, mutbl: to_mutbl }) = cast_to.kind();
+            if matches!((from_mutbl, to_mutbl),
+                (Mutability::Not, Mutability::Not) | (Mutability::Mut, Mutability::Mut));
+            // The `U` in `pointer::cast` have to be `Sized`
+            // as explained here: https://github.com/rust-lang/rust/issues/60602.
+            if to_pointee_ty.is_sized(cx.tcx.at(expr.span), cx.param_env);
+            then {
+                let mut applicability = Applicability::MachineApplicable;
+                let cast_expr_sugg = Sugg::hir_with_applicability(cx, cast_expr, "_", &mut applicability);
+                let turbofish = match &cast_to_hir_ty.kind {
+                        TyKind::Infer => Cow::Borrowed(""),
+                        TyKind::Ptr(mut_ty) if matches!(mut_ty.ty.kind, TyKind::Infer) => Cow::Borrowed(""),
+                        _ => Cow::Owned(format!("::<{}>", to_pointee_ty)),
+                    };
+                span_lint_and_sugg(
+                    cx,
+                    PTR_AS_PTR,
+                    expr.span,
+                    "`as` casting between raw pointers without changing its mutability",
+                    "try `pointer::cast`, a safer alternative",
+                    format!("{}.cast{}()", cast_expr_sugg.maybe_par(), turbofish),
+                    applicability,
+                );
+            }
+        }
+    }
+
+    extract_msrv_attr!(LateContext);
+}
diff --git a/clippy_lints/src/unnecessary_sort_by.rs b/clippy_lints/src/unnecessary_sort_by.rs
index 0bccfc156788a..9b45d38afd42f 100644
--- a/clippy_lints/src/unnecessary_sort_by.rs
+++ b/clippy_lints/src/unnecessary_sort_by.rs
@@ -183,7 +183,7 @@ fn detect_lint(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<LintTrigger> {
             Param { pat: Pat { kind: PatKind::Binding(_, _, right_ident, _), .. }, .. }
         ] = &closure_body.params;
         if let ExprKind::MethodCall(method_path, _, [ref left_expr, ref right_expr], _) = &closure_body.value.kind;
-        if method_path.ident.name.to_ident_string() == "cmp";
+        if method_path.ident.name == sym::cmp;
         then {
             let (closure_body, closure_arg, reverse) = if mirrored_exprs(
                 &cx,
diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index 07cd752184bbc..8ac5dd696b762 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -5,7 +5,7 @@ use crate::utils::{
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
-use rustc_hir::{Body, ExprKind, FnDecl, HirId, ItemKind, Impl, Node};
+use rustc_hir::{Body, ExprKind, FnDecl, HirId, Impl, ItemKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::subst::GenericArgKind;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/unused_self.rs b/clippy_lints/src/unused_self.rs
index a617179431107..5349c4f7eb8a7 100644
--- a/clippy_lints/src/unused_self.rs
+++ b/clippy_lints/src/unused_self.rs
@@ -1,7 +1,7 @@
 use if_chain::if_chain;
 use rustc_hir::def::Res;
 use rustc_hir::intravisit::{walk_path, NestedVisitorMap, Visitor};
-use rustc_hir::{HirId, ImplItem, ImplItemKind, ItemKind, Impl, Path};
+use rustc_hir::{HirId, Impl, ImplItem, ImplItemKind, ItemKind, Path};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs
index 6a87f53436980..b82909eaea604 100644
--- a/clippy_lints/src/unwrap.rs
+++ b/clippy_lints/src/unwrap.rs
@@ -1,6 +1,5 @@
 use crate::utils::{
-    differing_macro_contexts, is_type_diagnostic_item, span_lint_and_then,
-    usage::is_potentially_mutated,
+    differing_macro_contexts, is_type_diagnostic_item, span_lint_and_then, usage::is_potentially_mutated,
 };
 use if_chain::if_chain;
 use rustc_hir::intravisit::{walk_expr, walk_fn, FnKind, NestedVisitorMap, Visitor};
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index b82ea66190fcf..72d1ca7392913 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -28,8 +28,8 @@ declare_clippy_lint! {
     /// feels inconsistent.
     ///
     /// **Known problems:**
-    /// - False positive when using associated types (#2843)
-    /// - False positives in some situations when using generics (#3410)
+    /// - False positive when using associated types ([#2843](https://github.com/rust-lang/rust-clippy/issues/2843))
+    /// - False positives in some situations when using generics ([#3410](https://github.com/rust-lang/rust-clippy/issues/3410))
     ///
     /// **Example:**
     /// ```rust
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index efa9c3fab4ab8..c533485398605 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -80,10 +80,10 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                         );
                     }
                 }
-                if match_trait_method(cx, e, &paths::INTO_ITERATOR) && &*name.ident.as_str() == "into_iter" {
+                if match_trait_method(cx, e, &paths::INTO_ITERATOR) && name.ident.name == sym::into_iter {
                     if let Some(parent_expr) = get_parent_expr(cx, e) {
                         if let ExprKind::MethodCall(ref parent_name, ..) = parent_expr.kind {
-                            if &*parent_name.ident.as_str() != "into_iter" {
+                            if parent_name.ident.name != sym::into_iter {
                                 return;
                             }
                         }
diff --git a/clippy_lints/src/utils/attrs.rs b/clippy_lints/src/utils/attrs.rs
index 24052a243af82..8d28421d70d70 100644
--- a/clippy_lints/src/utils/attrs.rs
+++ b/clippy_lints/src/utils/attrs.rs
@@ -1,6 +1,7 @@
 use rustc_ast::ast;
 use rustc_errors::Applicability;
 use rustc_session::Session;
+use rustc_span::sym;
 use std::str::FromStr;
 
 /// Deprecation status of attributes known by Clippy.
@@ -64,11 +65,11 @@ pub fn get_attr<'a>(
             return false;
         };
         let attr_segments = &attr.path.segments;
-        if attr_segments.len() == 2 && attr_segments[0].ident.to_string() == "clippy" {
+        if attr_segments.len() == 2 && attr_segments[0].ident.name == sym::clippy {
             BUILTIN_ATTRIBUTES
                 .iter()
-                .find_map(|(builtin_name, deprecation_status)| {
-                    if *builtin_name == attr_segments[1].ident.to_string() {
+                .find_map(|&(builtin_name, ref deprecation_status)| {
+                    if attr_segments[1].ident.name.as_str() == builtin_name {
                         Some(deprecation_status)
                     } else {
                         None
@@ -99,7 +100,7 @@ pub fn get_attr<'a>(
                             },
                             DeprecationStatus::None => {
                                 diag.cancel();
-                                attr_segments[1].ident.to_string() == name
+                                attr_segments[1].ident.name.as_str() == name
                             },
                         }
                     },
diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs
index 062df68c0a482..10120a8805db2 100644
--- a/clippy_lints/src/utils/hir_utils.rs
+++ b/clippy_lints/src/utils/hir_utils.rs
@@ -86,7 +86,7 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
                 lb == rb && l_mut == r_mut && self.eq_expr(le, re)
             },
             (&ExprKind::Continue(li), &ExprKind::Continue(ri)) => {
-                both(&li.label, &ri.label, |l, r| l.ident.as_str() == r.ident.as_str())
+                both(&li.label, &ri.label, |l, r| l.ident.name == r.ident.name)
             },
             (&ExprKind::Assign(ref ll, ref lr, _), &ExprKind::Assign(ref rl, ref rr, _)) => {
                 self.allow_side_effects && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
@@ -102,7 +102,7 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
                     })
             },
             (&ExprKind::Break(li, ref le), &ExprKind::Break(ri, ref re)) => {
-                both(&li.label, &ri.label, |l, r| l.ident.as_str() == r.ident.as_str())
+                both(&li.label, &ri.label, |l, r| l.ident.name == r.ident.name)
                     && both(le, re, |l, r| self.eq_expr(l, r))
             },
             (&ExprKind::Box(ref l), &ExprKind::Box(ref r)) => self.eq_expr(l, r),
@@ -124,7 +124,7 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
             },
             (&ExprKind::Lit(ref l), &ExprKind::Lit(ref r)) => l.node == r.node,
             (&ExprKind::Loop(ref lb, ref ll, ref lls), &ExprKind::Loop(ref rb, ref rl, ref rls)) => {
-                lls == rls && self.eq_block(lb, rb) && both(ll, rl, |l, r| l.ident.as_str() == r.ident.as_str())
+                lls == rls && self.eq_block(lb, rb) && both(ll, rl, |l, r| l.ident.name == r.ident.name)
             },
             (&ExprKind::Match(ref le, ref la, ref ls), &ExprKind::Match(ref re, ref ra, ref rs)) => {
                 ls == rs
@@ -191,7 +191,7 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
 
     pub fn eq_fieldpat(&mut self, left: &FieldPat<'_>, right: &FieldPat<'_>) -> bool {
         let (FieldPat { ident: li, pat: lp, .. }, FieldPat { ident: ri, pat: rp, .. }) = (&left, &right);
-        li.name.as_str() == ri.name.as_str() && self.eq_pat(lp, rp)
+        li.name == ri.name && self.eq_pat(lp, rp)
     }
 
     /// Checks whether two patterns are the same.
@@ -205,7 +205,7 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
                 self.eq_qpath(lp, rp) && over(la, ra, |l, r| self.eq_pat(l, r)) && ls == rs
             },
             (&PatKind::Binding(ref lb, .., ref li, ref lp), &PatKind::Binding(ref rb, .., ref ri, ref rp)) => {
-                lb == rb && li.name.as_str() == ri.name.as_str() && both(lp, rp, |l, r| self.eq_pat(l, r))
+                lb == rb && li.name == ri.name && both(lp, rp, |l, r| self.eq_pat(l, r))
             },
             (&PatKind::Path(ref l), &PatKind::Path(ref r)) => self.eq_qpath(l, r),
             (&PatKind::Lit(ref l), &PatKind::Lit(ref r)) => self.eq_expr(l, r),
@@ -266,8 +266,7 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
     pub fn eq_path_segment(&mut self, left: &PathSegment<'_>, right: &PathSegment<'_>) -> bool {
         // The == of idents doesn't work with different contexts,
         // we have to be explicit about hygiene
-        left.ident.as_str() == right.ident.as_str()
-            && both(&left.args, &right.args, |l, r| self.eq_path_parameters(l, r))
+        left.ident.name == right.ident.name && both(&left.args, &right.args, |l, r| self.eq_path_parameters(l, r))
     }
 
     pub fn eq_ty(&mut self, left: &Ty<'_>, right: &Ty<'_>) -> bool {
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 407f06f489420..7aa17520ba79f 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -10,9 +10,12 @@ use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
+use rustc_hir::def_id::DefId;
 use rustc_hir::hir_id::CRATE_HIR_ID;
 use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
-use rustc_hir::{Crate, Expr, ExprKind, HirId, Item, MutTy, Mutability, Node, Path, StmtKind, Ty, TyKind};
+use rustc_hir::{
+    BinOpKind, Crate, Expr, ExprKind, HirId, Item, MutTy, Mutability, Node, Path, StmtKind, Ty, TyKind, UnOp,
+};
 use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
 use rustc_middle::mir::interpret::ConstValue;
@@ -272,6 +275,28 @@ declare_clippy_lint! {
     "interning a symbol that is pre-interned and defined as a constant"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for unnecessary conversion from Symbol to a string.
+    ///
+    /// **Why is this bad?** It's faster use symbols directly intead of strings.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// Bad:
+    /// ```rust,ignore
+    /// symbol.as_str() == "clippy";
+    /// ```
+    ///
+    /// Good:
+    /// ```rust,ignore
+    /// symbol == sym::clippy;
+    /// ```
+    pub UNNECESSARY_SYMBOL_STR,
+    internal,
+    "unnecessary conversion between Symbol and string"
+}
+
 declare_lint_pass!(ClippyLintsInternal => [CLIPPY_LINTS_INTERNAL]);
 
 impl EarlyLintPass for ClippyLintsInternal {
@@ -868,11 +893,11 @@ impl<'tcx> LateLintPass<'tcx> for InvalidPaths {
 
 #[derive(Default)]
 pub struct InterningDefinedSymbol {
-    // Maps the symbol value to the constant name.
-    symbol_map: FxHashMap<u32, String>,
+    // Maps the symbol value to the constant DefId.
+    symbol_map: FxHashMap<u32, DefId>,
 }
 
-impl_lint_pass!(InterningDefinedSymbol => [INTERNING_DEFINED_SYMBOL]);
+impl_lint_pass!(InterningDefinedSymbol => [INTERNING_DEFINED_SYMBOL, UNNECESSARY_SYMBOL_STR]);
 
 impl<'tcx> LateLintPass<'tcx> for InterningDefinedSymbol {
     fn check_crate(&mut self, cx: &LateContext<'_>, _: &Crate<'_>) {
@@ -880,16 +905,18 @@ impl<'tcx> LateLintPass<'tcx> for InterningDefinedSymbol {
             return;
         }
 
-        if let Some(Res::Def(_, def_id)) = path_to_res(cx, &paths::SYM_MODULE) {
-            for item in cx.tcx.item_children(def_id).iter() {
-                if_chain! {
-                    if let Res::Def(DefKind::Const, item_def_id) = item.res;
-                    let ty = cx.tcx.type_of(item_def_id);
-                    if match_type(cx, ty, &paths::SYMBOL);
-                    if let Ok(ConstValue::Scalar(value)) = cx.tcx.const_eval_poly(item_def_id);
-                    if let Ok(value) = value.to_u32();
-                    then {
-                        self.symbol_map.insert(value, item.ident.to_string());
+        for &module in &[&paths::KW_MODULE, &paths::SYM_MODULE] {
+            if let Some(Res::Def(_, def_id)) = path_to_res(cx, module) {
+                for item in cx.tcx.item_children(def_id).iter() {
+                    if_chain! {
+                        if let Res::Def(DefKind::Const, item_def_id) = item.res;
+                        let ty = cx.tcx.type_of(item_def_id);
+                        if match_type(cx, ty, &paths::SYMBOL);
+                        if let Ok(ConstValue::Scalar(value)) = cx.tcx.const_eval_poly(item_def_id);
+                        if let Ok(value) = value.to_u32();
+                        then {
+                            self.symbol_map.insert(value, item_def_id);
+                        }
                     }
                 }
             }
@@ -903,7 +930,7 @@ impl<'tcx> LateLintPass<'tcx> for InterningDefinedSymbol {
             if match_def_path(cx, *def_id, &paths::SYMBOL_INTERN);
             if let Some(Constant::Str(arg)) = constant_simple(cx, cx.typeck_results(), arg);
             let value = Symbol::intern(&arg).as_u32();
-            if let Some(symbol_const) = self.symbol_map.get(&value);
+            if let Some(&def_id) = self.symbol_map.get(&value);
             then {
                 span_lint_and_sugg(
                     cx,
@@ -911,10 +938,135 @@ impl<'tcx> LateLintPass<'tcx> for InterningDefinedSymbol {
                     is_expn_of(expr.span, "sym").unwrap_or(expr.span),
                     "interning a defined symbol",
                     "try",
-                    format!("rustc_span::symbol::sym::{}", symbol_const),
+                    cx.tcx.def_path_str(def_id),
                     Applicability::MachineApplicable,
                 );
             }
         }
+        if let ExprKind::Binary(op, left, right) = expr.kind {
+            if matches!(op.node, BinOpKind::Eq | BinOpKind::Ne) {
+                let data = [
+                    (left, self.symbol_str_expr(left, cx)),
+                    (right, self.symbol_str_expr(right, cx)),
+                ];
+                match data {
+                    // both operands are a symbol string
+                    [(_, Some(left)), (_, Some(right))] => {
+                        span_lint_and_sugg(
+                            cx,
+                            UNNECESSARY_SYMBOL_STR,
+                            expr.span,
+                            "unnecessary `Symbol` to string conversion",
+                            "try",
+                            format!(
+                                "{} {} {}",
+                                left.as_symbol_snippet(cx),
+                                op.node.as_str(),
+                                right.as_symbol_snippet(cx),
+                            ),
+                            Applicability::MachineApplicable,
+                        );
+                    },
+                    // one of the operands is a symbol string
+                    [(expr, Some(symbol)), _] | [_, (expr, Some(symbol))] => {
+                        // creating an owned string for comparison
+                        if matches!(symbol, SymbolStrExpr::Expr { is_to_owned: true, .. }) {
+                            span_lint_and_sugg(
+                                cx,
+                                UNNECESSARY_SYMBOL_STR,
+                                expr.span,
+                                "unnecessary string allocation",
+                                "try",
+                                format!("{}.as_str()", symbol.as_symbol_snippet(cx)),
+                                Applicability::MachineApplicable,
+                            );
+                        }
+                    },
+                    // nothing found
+                    [(_, None), (_, None)] => {},
+                }
+            }
+        }
+    }
+}
+
+impl InterningDefinedSymbol {
+    fn symbol_str_expr<'tcx>(&self, expr: &'tcx Expr<'tcx>, cx: &LateContext<'tcx>) -> Option<SymbolStrExpr<'tcx>> {
+        static IDENT_STR_PATHS: &[&[&str]] = &[&paths::IDENT_AS_STR, &paths::TO_STRING_METHOD];
+        static SYMBOL_STR_PATHS: &[&[&str]] = &[
+            &paths::SYMBOL_AS_STR,
+            &paths::SYMBOL_TO_IDENT_STRING,
+            &paths::TO_STRING_METHOD,
+        ];
+        // SymbolStr might be de-referenced: `&*symbol.as_str()`
+        let call = if_chain! {
+            if let ExprKind::AddrOf(_, _, e) = expr.kind;
+            if let ExprKind::Unary(UnOp::UnDeref, e) = e.kind;
+            then { e } else { expr }
+        };
+        if_chain! {
+            // is a method call
+            if let ExprKind::MethodCall(_, _, [item], _) = call.kind;
+            if let Some(did) = cx.typeck_results().type_dependent_def_id(call.hir_id);
+            let ty = cx.typeck_results().expr_ty(item);
+            // ...on either an Ident or a Symbol
+            if let Some(is_ident) = if match_type(cx, ty, &paths::SYMBOL) {
+                Some(false)
+            } else if match_type(cx, ty, &paths::IDENT) {
+                Some(true)
+            } else {
+                None
+            };
+            // ...which converts it to a string
+            let paths = if is_ident { IDENT_STR_PATHS } else { SYMBOL_STR_PATHS };
+            if let Some(path) = paths.iter().find(|path| match_def_path(cx, did, path));
+            then {
+                let is_to_owned = path.last().unwrap().ends_with("string");
+                return Some(SymbolStrExpr::Expr {
+                    item,
+                    is_ident,
+                    is_to_owned,
+                });
+            }
+        }
+        // is a string constant
+        if let Some(Constant::Str(s)) = constant_simple(cx, cx.typeck_results(), expr) {
+            let value = Symbol::intern(&s).as_u32();
+            // ...which matches a symbol constant
+            if let Some(&def_id) = self.symbol_map.get(&value) {
+                return Some(SymbolStrExpr::Const(def_id));
+            }
+        }
+        None
+    }
+}
+
+enum SymbolStrExpr<'tcx> {
+    /// a string constant with a corresponding symbol constant
+    Const(DefId),
+    /// a "symbol to string" expression like `symbol.as_str()`
+    Expr {
+        /// part that evaluates to `Symbol` or `Ident`
+        item: &'tcx Expr<'tcx>,
+        is_ident: bool,
+        /// whether an owned `String` is created like `to_ident_string()`
+        is_to_owned: bool,
+    },
+}
+
+impl<'tcx> SymbolStrExpr<'tcx> {
+    /// Returns a snippet that evaluates to a `Symbol` and is const if possible
+    fn as_symbol_snippet(&self, cx: &LateContext<'_>) -> Cow<'tcx, str> {
+        match *self {
+            Self::Const(def_id) => cx.tcx.def_path_str(def_id).into(),
+            Self::Expr { item, is_ident, .. } => {
+                let mut snip = snippet(cx, item.span.source_callsite(), "..");
+                if is_ident {
+                    // get `Ident.name`
+                    snip.to_mut().push_str(".name");
+                }
+                snip
+            },
+        }
     }
 }
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 3e39a47f1963d..548c4f7510ad5 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -1,5 +1,5 @@
 #[macro_use]
-pub mod sym;
+pub mod sym_helper;
 
 #[allow(clippy::module_name_repetitions)]
 pub mod ast_utils;
@@ -56,8 +56,8 @@ use rustc_semver::RustcVersion;
 use rustc_session::Session;
 use rustc_span::hygiene::{ExpnKind, MacroKind};
 use rustc_span::source_map::original_sp;
-use rustc_span::sym as rustc_sym;
-use rustc_span::symbol::{self, kw, Symbol};
+use rustc_span::sym;
+use rustc_span::symbol::{kw, Symbol};
 use rustc_span::{BytePos, Pos, Span, DUMMY_SP};
 use rustc_target::abi::Integer;
 use rustc_trait_selection::traits::query::normalize::AtExt;
@@ -1121,7 +1121,7 @@ pub fn is_refutable(cx: &LateContext<'_>, pat: &Pat<'_>) -> bool {
 /// Checks for the `#[automatically_derived]` attribute all `#[derive]`d
 /// implementations have.
 pub fn is_automatically_derived(attrs: &[ast::Attribute]) -> bool {
-    attrs.iter().any(|attr| attr.has_name(rustc_sym::automatically_derived))
+    attrs.iter().any(|attr| attr.has_name(sym::automatically_derived))
 }
 
 /// Remove blocks around an expression.
@@ -1434,12 +1434,13 @@ pub fn parent_node_is_if_expr(expr: &Expr<'_>, cx: &LateContext<'_>) -> bool {
     let map = cx.tcx.hir();
     let parent_id = map.get_parent_node(expr.hir_id);
     let parent_node = map.get(parent_id);
-    if let Node::Expr(Expr { kind: ExprKind::If(_, _, _), .. }) = parent_node {
-        true
-    }
-    else {
-        false
-    }
+    matches!(
+        parent_node,
+        Node::Expr(Expr {
+            kind: ExprKind::If(_, _, _),
+            ..
+        })
+    )
 }
 
 // Finds the attribute with the given name, if any
@@ -1514,7 +1515,7 @@ pub fn is_must_use_func_call(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
 pub fn is_no_std_crate(krate: &Crate<'_>) -> bool {
     krate.item.attrs.iter().any(|attr| {
         if let ast::AttrKind::Normal(ref attr, _) = attr.kind {
-            attr.path == symbol::sym::no_std
+            attr.path == sym::no_std
         } else {
             false
         }
@@ -1686,6 +1687,18 @@ macro_rules! unwrap_cargo_metadata {
     }};
 }
 
+pub fn is_hir_ty_cfg_dependant(cx: &LateContext<'_>, ty: &hir::Ty<'_>) -> bool {
+    if_chain! {
+        if let TyKind::Path(QPath::Resolved(_, path)) = ty.kind;
+        if let Res::Def(_, def_id) = path.res;
+        then {
+            cx.tcx.has_attr(def_id, sym::cfg) || cx.tcx.has_attr(def_id, sym::cfg_attr)
+        } else {
+            false
+        }
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::{reindent_multiline, without_block_comments};
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index 2080a49a11cd6..c0b203b5388dc 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -54,6 +54,10 @@ pub const HASH: [&str; 3] = ["core", "hash", "Hash"];
 pub const HASHMAP: [&str; 5] = ["std", "collections", "hash", "map", "HashMap"];
 pub const HASHMAP_ENTRY: [&str; 5] = ["std", "collections", "hash", "map", "Entry"];
 pub const HASHSET: [&str; 5] = ["std", "collections", "hash", "set", "HashSet"];
+#[cfg(feature = "internal-lints")]
+pub const IDENT: [&str; 3] = ["rustc_span", "symbol", "Ident"];
+#[cfg(feature = "internal-lints")]
+pub const IDENT_AS_STR: [&str; 4] = ["rustc_span", "symbol", "Ident", "as_str"];
 pub const INDEX: [&str; 3] = ["core", "ops", "Index"];
 pub const INDEX_MUT: [&str; 3] = ["core", "ops", "IndexMut"];
 pub const INSERT_STR: [&str; 4] = ["alloc", "string", "String", "insert_str"];
@@ -65,6 +69,8 @@ pub const IPADDR_V4: [&str; 4] = ["std", "net", "IpAddr", "V4"];
 pub const IPADDR_V6: [&str; 4] = ["std", "net", "IpAddr", "V6"];
 pub const ITERATOR: [&str; 5] = ["core", "iter", "traits", "iterator", "Iterator"];
 #[cfg(feature = "internal-lints")]
+pub const KW_MODULE: [&str; 3] = ["rustc_span", "symbol", "kw"];
+#[cfg(feature = "internal-lints")]
 pub const LATE_CONTEXT: [&str; 2] = ["rustc_lint", "LateContext"];
 pub const LINKED_LIST: [&str; 4] = ["alloc", "collections", "linked_list", "LinkedList"];
 #[cfg(feature = "internal-lints")]
@@ -148,8 +154,12 @@ pub const STR_STARTS_WITH: [&str; 4] = ["core", "str", "<impl str>", "starts_wit
 #[cfg(feature = "internal-lints")]
 pub const SYMBOL: [&str; 3] = ["rustc_span", "symbol", "Symbol"];
 #[cfg(feature = "internal-lints")]
+pub const SYMBOL_AS_STR: [&str; 4] = ["rustc_span", "symbol", "Symbol", "as_str"];
+#[cfg(feature = "internal-lints")]
 pub const SYMBOL_INTERN: [&str; 4] = ["rustc_span", "symbol", "Symbol", "intern"];
 #[cfg(feature = "internal-lints")]
+pub const SYMBOL_TO_IDENT_STRING: [&str; 4] = ["rustc_span", "symbol", "Symbol", "to_ident_string"];
+#[cfg(feature = "internal-lints")]
 pub const SYM_MODULE: [&str; 3] = ["rustc_span", "symbol", "sym"];
 #[cfg(feature = "internal-lints")]
 pub const SYNTAX_CONTEXT: [&str; 3] = ["rustc_span", "hygiene", "SyntaxContext"];
diff --git a/clippy_lints/src/utils/sym.rs b/clippy_lints/src/utils/sym_helper.rs
similarity index 68%
rename from clippy_lints/src/utils/sym.rs
rename to clippy_lints/src/utils/sym_helper.rs
index 273288c3d52c5..f47dc80ebade8 100644
--- a/clippy_lints/src/utils/sym.rs
+++ b/clippy_lints/src/utils/sym_helper.rs
@@ -1,4 +1,5 @@
 #[macro_export]
+/// Convenience wrapper around rustc's `Symbol::intern`
 macro_rules! sym {
     ($tt:tt) => {
         rustc_span::symbol::Symbol::intern(stringify!($tt))
diff --git a/clippy_lints/src/utils/visitors.rs b/clippy_lints/src/utils/visitors.rs
index b769a18802b6b..ebf69df31ca41 100644
--- a/clippy_lints/src/utils/visitors.rs
+++ b/clippy_lints/src/utils/visitors.rs
@@ -107,7 +107,7 @@ where
                         if let Some(el) = else_opt {
                             self.visit_expr(el);
                         }
-                    }
+                    },
                     hir::ExprKind::Match(cond, arms, _) => {
                         self.inside_stmt(true).visit_expr(cond);
                         for arm in arms {
diff --git a/clippy_lints/src/vec_init_then_push.rs b/clippy_lints/src/vec_init_then_push.rs
new file mode 100644
index 0000000000000..e632a7e57ee87
--- /dev/null
+++ b/clippy_lints/src/vec_init_then_push.rs
@@ -0,0 +1,187 @@
+use crate::utils::{is_type_diagnostic_item, match_def_path, paths, snippet, span_lint_and_sugg};
+use if_chain::if_chain;
+use rustc_ast::ast::LitKind;
+use rustc_errors::Applicability;
+use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, Local, PatKind, QPath, Stmt, StmtKind};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::{symbol::sym, Span, Symbol};
+use std::convert::TryInto;
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for calls to `push` immediately after creating a new `Vec`.
+    ///
+    /// **Why is this bad?** The `vec![]` macro is both more performant and easier to read than
+    /// multiple `push` calls.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// let mut v = Vec::new();
+    /// v.push(0);
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let v = vec![0];
+    /// ```
+    pub VEC_INIT_THEN_PUSH,
+    perf,
+    "`push` immediately after `Vec` creation"
+}
+
+impl_lint_pass!(VecInitThenPush => [VEC_INIT_THEN_PUSH]);
+
+#[derive(Default)]
+pub struct VecInitThenPush {
+    searcher: Option<VecPushSearcher>,
+}
+
+#[derive(Clone, Copy)]
+enum VecInitKind {
+    New,
+    WithCapacity(u64),
+}
+struct VecPushSearcher {
+    init: VecInitKind,
+    name: Symbol,
+    lhs_is_local: bool,
+    lhs_span: Span,
+    err_span: Span,
+    found: u64,
+}
+impl VecPushSearcher {
+    fn display_err(&self, cx: &LateContext<'_>) {
+        match self.init {
+            _ if self.found == 0 => return,
+            VecInitKind::WithCapacity(x) if x > self.found => return,
+            _ => (),
+        };
+
+        let mut s = if self.lhs_is_local {
+            String::from("let ")
+        } else {
+            String::new()
+        };
+        s.push_str(&snippet(cx, self.lhs_span, ".."));
+        s.push_str(" = vec![..];");
+
+        span_lint_and_sugg(
+            cx,
+            VEC_INIT_THEN_PUSH,
+            self.err_span,
+            "calls to `push` immediately after creation",
+            "consider using the `vec![]` macro",
+            s,
+            Applicability::HasPlaceholders,
+        );
+    }
+}
+
+impl LateLintPass<'_> for VecInitThenPush {
+    fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'tcx>) {
+        self.searcher = None;
+        if_chain! {
+            if !in_external_macro(cx.sess(), local.span);
+            if let Some(init) = local.init;
+            if let PatKind::Binding(BindingAnnotation::Mutable, _, ident, None) = local.pat.kind;
+            if let Some(init_kind) = get_vec_init_kind(cx, init);
+            then {
+                self.searcher = Some(VecPushSearcher {
+                        init: init_kind,
+                        name: ident.name,
+                        lhs_is_local: true,
+                        lhs_span: local.ty.map_or(local.pat.span, |t| local.pat.span.to(t.span)),
+                        err_span: local.span,
+                        found: 0,
+                    });
+            }
+        }
+    }
+
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if self.searcher.is_none() {
+            if_chain! {
+                if !in_external_macro(cx.sess(), expr.span);
+                if let ExprKind::Assign(left, right, _) = expr.kind;
+                if let ExprKind::Path(QPath::Resolved(_, path)) = left.kind;
+                if let Some(name) = path.segments.get(0);
+                if let Some(init_kind) = get_vec_init_kind(cx, right);
+                then {
+                    self.searcher = Some(VecPushSearcher {
+                        init: init_kind,
+                        name: name.ident.name,
+                        lhs_is_local: false,
+                        lhs_span: left.span,
+                        err_span: expr.span,
+                        found: 0,
+                    });
+                }
+            }
+        }
+    }
+
+    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
+        if let Some(searcher) = self.searcher.take() {
+            if_chain! {
+                if let StmtKind::Expr(expr) | StmtKind::Semi(expr) = stmt.kind;
+                if let ExprKind::MethodCall(path, _, [self_arg, _], _) = expr.kind;
+                if path.ident.name.as_str() == "push";
+                if let ExprKind::Path(QPath::Resolved(_, self_path)) = self_arg.kind;
+                if let [self_name] = self_path.segments;
+                if self_name.ident.name == searcher.name;
+                then {
+                    self.searcher = Some(VecPushSearcher {
+                        found: searcher.found + 1,
+                        err_span: searcher.err_span.to(stmt.span),
+                        .. searcher
+                    });
+                } else {
+                    searcher.display_err(cx);
+                }
+            }
+        }
+    }
+
+    fn check_block_post(&mut self, cx: &LateContext<'tcx>, _: &'tcx Block<'tcx>) {
+        if let Some(searcher) = self.searcher.take() {
+            searcher.display_err(cx);
+        }
+    }
+}
+
+fn get_vec_init_kind<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<VecInitKind> {
+    if let ExprKind::Call(func, args) = expr.kind {
+        match func.kind {
+            ExprKind::Path(QPath::TypeRelative(ty, name))
+                if is_type_diagnostic_item(cx, cx.typeck_results().node_type(ty.hir_id), sym::vec_type) =>
+            {
+                if name.ident.name == sym::new {
+                    return Some(VecInitKind::New);
+                } else if name.ident.name.as_str() == "with_capacity" {
+                    return args.get(0).and_then(|arg| {
+                        if_chain! {
+                            if let ExprKind::Lit(lit) = &arg.kind;
+                            if let LitKind::Int(num, _) = lit.node;
+                            then {
+                                Some(VecInitKind::WithCapacity(num.try_into().ok()?))
+                            } else {
+                                None
+                            }
+                        }
+                    });
+                }
+            }
+            ExprKind::Path(QPath::Resolved(_, path))
+                if match_def_path(cx, path.res.opt_def_id()?, &paths::DEFAULT_TRAIT_METHOD)
+                    && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(expr), sym::vec_type) =>
+            {
+                return Some(VecInitKind::New);
+            }
+            _ => (),
+        }
+    }
+    None
+}
diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index 5683a71efea4e..10005a7fc81ed 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -7,7 +7,8 @@ use rustc_hir::{
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::BytePos;
+use rustc_span::symbol::kw;
+use rustc_span::{sym, BytePos};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for `use Enum::*`.
@@ -198,12 +199,12 @@ impl WildcardImports {
 // Allow "...prelude::..::*" imports.
 // Many crates have a prelude, and it is imported as a glob by design.
 fn is_prelude_import(segments: &[PathSegment<'_>]) -> bool {
-    segments.iter().any(|ps| ps.ident.as_str() == "prelude")
+    segments.iter().any(|ps| ps.ident.name == sym::prelude)
 }
 
 // Allow "super::*" imports in tests.
 fn is_super_only_import(segments: &[PathSegment<'_>]) -> bool {
-    segments.len() == 1 && segments[0].ident.as_str() == "super"
+    segments.len() == 1 && segments[0].ident.name == kw::Super
 }
 
 fn is_test_module_or_function(item: &Item<'_>) -> bool {
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 337f7a229b906..af324f831dfa2 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -10,7 +10,8 @@ use rustc_lexer::unescape::{self, EscapeError};
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_parse::parser;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{sym, BytePos, Span, Symbol};
+use rustc_span::symbol::kw;
+use rustc_span::{sym, BytePos, Span};
 
 declare_clippy_lint! {
     /// **What it does:** This lint warns when you use `println!("")` to
@@ -301,7 +302,7 @@ impl EarlyLintPass for Write {
             }
         } else if mac.path == sym!(writeln) {
             if let (Some(fmt_str), expr) = self.check_tts(cx, mac.args.inner_tokens(), true) {
-                if fmt_str.symbol == Symbol::intern("") {
+                if fmt_str.symbol == kw::Empty {
                     let mut applicability = Applicability::MachineApplicable;
                     // FIXME: remove this `#[allow(...)]` once the issue #5822 gets fixed
                     #[allow(clippy::option_if_let_else)]
@@ -484,7 +485,7 @@ impl Write {
 
     fn lint_println_empty_string(&self, cx: &EarlyContext<'_>, mac: &MacCall) {
         if let (Some(fmt_str), _) = self.check_tts(cx, mac.args.inner_tokens(), false) {
-            if fmt_str.symbol == Symbol::intern("") {
+            if fmt_str.symbol == kw::Empty {
                 let name = mac.path.segments[0].ident.name;
                 span_lint_and_sugg(
                     cx,
diff --git a/doc/adding_lints.md b/doc/adding_lints.md
index 60dfdb76650a1..1a7a30c61be5b 100644
--- a/doc/adding_lints.md
+++ b/doc/adding_lints.md
@@ -147,10 +147,14 @@ add `// edition:2018` at the top of the test file (note that it's space-sensitiv
 
 Manually testing against an example file can be useful if you have added some
 `println!`s and the test suite output becomes unreadable. To try Clippy with
-your local modifications, run `env CLIPPY_TESTS=true cargo run --bin
-clippy-driver -- -L ./target/debug input.rs` from the working copy root.
+your local modifications, run
 
-With tests in place, let's have a look at implementing our lint now.
+```
+env __CLIPPY_INTERNAL_TESTS=true cargo run --bin clippy-driver -- -L ./target/debug input.rs
+```
+
+from the working copy root. With tests in place, let's have a look at
+implementing our lint now.
 
 ## Lint declaration
 
diff --git a/doc/roadmap-2021.md b/doc/roadmap-2021.md
new file mode 100644
index 0000000000000..fe8b080f56f2b
--- /dev/null
+++ b/doc/roadmap-2021.md
@@ -0,0 +1,235 @@
+# Roadmap 2021
+
+# Summary
+
+This Roadmap lays out the plans for Clippy in 2021:
+
+- Improving usability and reliability
+- Improving experience of contributors and maintainers
+- Develop and specify processes
+
+Members of the Clippy team will be assigned tasks from one or more of these
+topics. The team member is then responsible to complete the assigned tasks. This
+can either be done by implementing them or by providing mentorship to interested
+contributors.
+
+# Motivation
+
+With the ongoing growth of the Rust language and with that of the whole
+ecosystem, also Clippy gets more and more users and contributors. This is good
+for the project, but also brings challenges along. Some of these challenges are:
+
+- More issues about reliability or usability are popping up
+- Traffic is hard to handle for a small team
+- Bigger projects don't get completed due to the lack of processes and/or time
+  of the team members
+
+Additionally, according to the [Rust Roadmap 2021], clear processes should be
+defined by every team and unified across teams. This Roadmap is the first step
+towards this.
+
+[Rust Roadmap 2021]: https://github.com/rust-lang/rfcs/pull/3037
+
+# Explanation
+
+This section will explain the things that should be done in 2021. It is
+important to note, that this document focuses on the "What?", not the "How?".
+The later will be addressed in follow-up tracking issue, with an assigned team
+member.
+
+The following is split up in two major sections. The first section covers the
+user facing plans, the second section the internal plans.
+
+## User Facing
+
+Clippy should be as pleasant to use and configure as possible. This section
+covers plans that should be implemented to improve the situation of Clippy in
+this regard.
+
+### Usability
+
+In the following, plans to improve the usability are covered.
+
+#### No Output After `cargo check`
+
+Currently when `cargo clippy` is run after `cargo check`, it does not produce
+any output. This is especially problematic since `rust-analyzer` is on the rise
+and it uses `cargo check` for checking code. A fix is already implemented, but
+it still has to be pushed over the finish line. This also includes the
+stabilization of the `cargo clippy --fix` command or the support of multi-span
+suggestions in `rustfix`.
+
+- [#4612](https://github.com/rust-lang/rust-clippy/issues/4612)
+
+#### `lints.toml` Configuration
+
+This is something that comes up every now and then: a reusable configuration
+file, where lint levels can be defined. Discussions about this often lead to
+nothing specific or to "we need an RFC for this". And this is exactly what needs
+to be done. Get together with the cargo team and write an RFC and implement such
+a configuration file somehow and somewhere.
+
+- [#3164](https://github.com/rust-lang/rust-clippy/issues/3164)
+- [cargo#5034](https://github.com/rust-lang/cargo/issues/5034)
+- [IRLO](https://internals.rust-lang.org/t/proposal-cargo-lint-configuration/9135/8)
+
+#### Lint Groups
+
+There are more and more issues about managing lints in Clippy popping up. Lints
+are hard to implement with a guarantee of no/few false positives (FPs). One way
+to address this might be to introduce more lint groups to give users the ability
+to better manage lints, or improve the process of classifying lints, so that
+disabling lints due to FPs becomes rare. It is important to note, that Clippy
+lints are less conservative than `rustc` lints, which won't change in the
+future.
+
+- [#5537](https://github.com/rust-lang/rust-clippy/issues/5537)
+- [#6366](https://github.com/rust-lang/rust-clippy/issues/6366)
+
+### Reliability
+
+In the following, plans to improve the reliability are covered.
+
+#### False Positive Rate
+
+In the worst case, new lints are only available in nightly for 2 weeks, before
+hitting beta and ultimately stable. This and the fact that fewer people use
+nightly Rust nowadays makes it more probable that a lint with many FPs hits
+stable. This leads to annoyed users, that will disable these new lints in the
+best case and to more annoyed users, that will stop using Clippy in the worst.
+A process should be developed and implemented to prevent this from happening.
+
+- [#6429](https://github.com/rust-lang/rust-clippy/issues/6429)
+
+## Internal
+
+(The end of) 2020 has shown, that Clippy has to think about the available
+resources, especially regarding management and maintenance of the project. This
+section address issues affecting team members and contributors.
+
+### Management
+
+In 2020 Clippy achieved over 1000 open issues with regularly between 25-35 open
+PRs. This is simultaneously a win and a loss. More issues and PRs means more
+people are interested in Clippy and in contributing to it. On the other hand, it
+means for team members more work and for contributors longer wait times for
+reviews. The following will describe plans how to improve the situation for both
+team members and contributors.
+
+#### Clear Expectations for Team Members
+
+According to the [Rust Roadmap 2021], a document specifying what it means to be
+a member of the team should be produced. This should not put more pressure on
+the team members, but rather help them and interested folks to know what the
+expectations are. With this it should also be easier to recruit new team members
+and may encourage people to get in touch, if they're interested to join.
+
+#### Scaling up the Team
+
+More people means less work for each individual. Together with the document
+about expectations for team members, a document defining the process of how to
+join the team should be produced. This can also increase the stability of the
+team, in case of current members dropping out (temporarily). There can also be
+different roles in the team, like people triaging vs. people reviewing.
+
+#### Regular Meetings
+
+Other teams have regular meetings. Clippy is big enough that it might be worth
+to also do them. Especially if more people join the team, this can be important
+for sync-ups. Besides the asynchronous communication, that works well for
+working on separate lints, a meeting adds a synchronous alternative at a known
+time. This is especially helpful if there are bigger things that need to be
+discussed (like the projects in this roadmap). For starters bi-weekly meetings
+before Rust syncs might make sense.
+
+#### Triaging
+
+To get a handle on the influx of open issues, a process for triaging issues and
+PRs should be developed. Officially, Clippy follows the Rust triage process, but
+currently no one enforces it. This can be improved by sharing triage teams
+across projects or by implementing dashboards / tools which simplify triaging.
+
+### Development
+
+Improving the developer and contributor experience is something the Clippy team
+works on regularly. Though, some things might need special attention and
+planing. These topics are listed in the following.
+
+#### Process for New and Existing Lints
+
+As already mentioned above, classifying new lints gets quite hard, because the
+probability of a buggy lint getting into stable is quite high. A process should
+be implemented on how to classify lints. In addition, a test system should be
+developed to find out which lints are currently problematic in real world code
+to fix or disable them.
+
+- [#6429 (comment)](https://github.com/rust-lang/rust-clippy/issues/6429#issuecomment-741056379)
+- [#6429 (comment)](https://github.com/rust-lang/rust-clippy/issues/6429#issuecomment-741153345)
+
+#### Processes
+
+Related to the point before, a process for suggesting and discussing major
+changes should be implemented. It's also not clearly defined when a lint should
+be enabled or disabled by default. This can also be improved by the test system
+mentioned above.
+
+#### Dev-Tools
+
+There's already `cargo dev` which makes Clippy development easier and more
+pleasant. This can still be expanded, so that it covers more areas of the
+development process.
+
+- [#5394](https://github.com/rust-lang/rust-clippy/issues/5394)
+
+#### Contributor Guide
+
+Similar to a Clippy Book, which describes how to use Clippy, a book about how to
+contribute to Clippy might be helpful for new and existing contributors. There's
+already the `doc` directory in the Clippy repo, this can be turned into a
+`mdbook`.
+
+#### `rustc` integration
+
+Recently Clippy was integrated with `git subtree` into the `rust-lang/rust`
+repository. This made syncing between the two repositories easier. A
+`#[non_exhaustive]` list of things that still can be improved is:
+
+1. Use the same `rustfmt` version and configuration as `rustc`.
+2. Make `cargo dev` work in the Rust repo, just as it works in the Clippy repo.
+   E.g. `cargo dev bless` or `cargo dev update_lints`. And even add more things
+   to it that might be useful for the Rust repo, e.g. `cargo dev deprecate`.
+3. Easier sync process. The `subtree` situation is not ideal.
+
+## Prioritization
+
+The most pressing issues for users of Clippy are of course the user facing
+issues. So there should be a priority on those issues, but without losing track
+of the internal issues listed in this document.
+
+Getting the FP rate of warn/deny-by-default lints under control should have the
+highest priority. Other user facing issues should also get a high priority, but
+shouldn't be in the way of addressing internal issues.
+
+To better manage the upcoming projects, the basic internal processes, like
+meetings, tracking issues and documentation, should be established as soon as
+possible. They might even be necessary to properly manage the projects,
+regarding the user facing issues.
+
+# Prior Art
+
+## Rust Roadmap
+
+Rust's roadmap process was established by [RFC 1728] in 2016. Since then every
+year a roadmap was published, that defined the bigger plans for the coming
+years. This years roadmap can be found [here][Rust Roadmap 2021].
+
+[RFC 1728]: https://rust-lang.github.io/rfcs/1728-north-star.html
+
+# Drawbacks
+
+## Big Roadmap
+
+This roadmap is pretty big and not all items listed in this document might be
+addressed during 2021. Because this is the first roadmap for Clippy, having open
+tasks at the end of 2021 is fine, but they should be revisited in the 2022
+roadmap.
diff --git a/rust-toolchain b/rust-toolchain
index c579beeae89be..72935072f8cdd 100644
--- a/rust-toolchain
+++ b/rust-toolchain
@@ -1,3 +1,3 @@
 [toolchain]
-channel = "nightly-2021-01-02"
+channel = "nightly-2021-01-15"
 components = ["llvm-tools-preview", "rustc-dev", "rust-src", "rustfmt"]
diff --git a/src/driver.rs b/src/driver.rs
index e490ee54c0be0..f5f6c09ed8e94 100644
--- a/src/driver.rs
+++ b/src/driver.rs
@@ -298,7 +298,7 @@ pub fn main() {
         // - IF Clippy is run on the main crate, not on deps (`!cap_lints_allow`) THEN
         //    - IF `--no-deps` is not set (`!no_deps`) OR
         //    - IF `--no-deps` is set and Clippy is run on the specified primary package
-        let clippy_tests_set = env::var("CLIPPY_TESTS").map_or(false, |val| val == "true");
+        let clippy_tests_set = env::var("__CLIPPY_INTERNAL_TESTS").map_or(false, |val| val == "true");
         let cap_lints_allow = arg_value(&orig_args, "--cap-lints", |val| val == "allow").is_some();
         let in_primary_package = env::var("CARGO_PRIMARY_PACKAGE").is_ok();
 
diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index ec3af94b9ca91..ea800336ef550 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -254,7 +254,7 @@ fn run_ui_cargo(config: &mut compiletest::Config) {
 
 fn prepare_env() {
     set_var("CLIPPY_DISABLE_DOCS_LINKS", "true");
-    set_var("CLIPPY_TESTS", "true");
+    set_var("__CLIPPY_INTERNAL_TESTS", "true");
     //set_var("RUST_BACKTRACE", "0");
 }
 
diff --git a/tests/ui-internal/interning_defined_symbol.fixed b/tests/ui-internal/interning_defined_symbol.fixed
index c6b84d2ef650b..9ab845a573aca 100644
--- a/tests/ui-internal/interning_defined_symbol.fixed
+++ b/tests/ui-internal/interning_defined_symbol.fixed
@@ -14,13 +14,16 @@ macro_rules! sym {
 
 fn main() {
     // Direct use of Symbol::intern
-    let _ = rustc_span::symbol::sym::f32;
+    let _ = rustc_span::sym::f32;
 
     // Using a sym macro
-    let _ = rustc_span::symbol::sym::f32;
+    let _ = rustc_span::sym::f32;
 
     // Correct suggestion when symbol isn't stringified constant name
-    let _ = rustc_span::symbol::sym::proc_dash_macro;
+    let _ = rustc_span::sym::proc_dash_macro;
+
+    // interning a keyword
+    let _ = rustc_span::symbol::kw::SelfLower;
 
     // Interning a symbol that is not defined
     let _ = Symbol::intern("xyz123");
diff --git a/tests/ui-internal/interning_defined_symbol.rs b/tests/ui-internal/interning_defined_symbol.rs
index 9ec82d4ad0bae..a58e182971d73 100644
--- a/tests/ui-internal/interning_defined_symbol.rs
+++ b/tests/ui-internal/interning_defined_symbol.rs
@@ -22,6 +22,9 @@ fn main() {
     // Correct suggestion when symbol isn't stringified constant name
     let _ = Symbol::intern("proc-macro");
 
+    // interning a keyword
+    let _ = Symbol::intern("self");
+
     // Interning a symbol that is not defined
     let _ = Symbol::intern("xyz123");
     let _ = sym!(xyz123);
diff --git a/tests/ui-internal/interning_defined_symbol.stderr b/tests/ui-internal/interning_defined_symbol.stderr
index 74b906c8a5797..50c1c268eb132 100644
--- a/tests/ui-internal/interning_defined_symbol.stderr
+++ b/tests/ui-internal/interning_defined_symbol.stderr
@@ -2,7 +2,7 @@ error: interning a defined symbol
   --> $DIR/interning_defined_symbol.rs:17:13
    |
 LL |     let _ = Symbol::intern("f32");
-   |             ^^^^^^^^^^^^^^^^^^^^^ help: try: `rustc_span::symbol::sym::f32`
+   |             ^^^^^^^^^^^^^^^^^^^^^ help: try: `rustc_span::sym::f32`
    |
 note: the lint level is defined here
   --> $DIR/interning_defined_symbol.rs:2:9
@@ -15,13 +15,19 @@ error: interning a defined symbol
   --> $DIR/interning_defined_symbol.rs:20:13
    |
 LL |     let _ = sym!(f32);
-   |             ^^^^^^^^^ help: try: `rustc_span::symbol::sym::f32`
+   |             ^^^^^^^^^ help: try: `rustc_span::sym::f32`
 
 error: interning a defined symbol
   --> $DIR/interning_defined_symbol.rs:23:13
    |
 LL |     let _ = Symbol::intern("proc-macro");
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `rustc_span::symbol::sym::proc_dash_macro`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `rustc_span::sym::proc_dash_macro`
 
-error: aborting due to 3 previous errors
+error: interning a defined symbol
+  --> $DIR/interning_defined_symbol.rs:26:13
+   |
+LL |     let _ = Symbol::intern("self");
+   |             ^^^^^^^^^^^^^^^^^^^^^^ help: try: `rustc_span::symbol::kw::SelfLower`
+
+error: aborting due to 4 previous errors
 
diff --git a/tests/ui-internal/unnecessary_symbol_str.fixed b/tests/ui-internal/unnecessary_symbol_str.fixed
new file mode 100644
index 0000000000000..2ec0efe4c10a5
--- /dev/null
+++ b/tests/ui-internal/unnecessary_symbol_str.fixed
@@ -0,0 +1,16 @@
+// run-rustfix
+#![feature(rustc_private)]
+#![deny(clippy::internal)]
+#![allow(clippy::unnecessary_operation, unused_must_use)]
+
+extern crate rustc_span;
+
+use rustc_span::symbol::{Ident, Symbol};
+
+fn main() {
+    Symbol::intern("foo") == rustc_span::sym::clippy;
+    Symbol::intern("foo") == rustc_span::symbol::kw::SelfLower;
+    Symbol::intern("foo") != rustc_span::symbol::kw::SelfUpper;
+    Ident::invalid().name == rustc_span::sym::clippy;
+    rustc_span::sym::clippy == Ident::invalid().name;
+}
diff --git a/tests/ui-internal/unnecessary_symbol_str.rs b/tests/ui-internal/unnecessary_symbol_str.rs
new file mode 100644
index 0000000000000..87e1b3a2ee76a
--- /dev/null
+++ b/tests/ui-internal/unnecessary_symbol_str.rs
@@ -0,0 +1,16 @@
+// run-rustfix
+#![feature(rustc_private)]
+#![deny(clippy::internal)]
+#![allow(clippy::unnecessary_operation, unused_must_use)]
+
+extern crate rustc_span;
+
+use rustc_span::symbol::{Ident, Symbol};
+
+fn main() {
+    Symbol::intern("foo").as_str() == "clippy";
+    Symbol::intern("foo").to_string() == "self";
+    Symbol::intern("foo").to_ident_string() != "Self";
+    &*Ident::invalid().as_str() == "clippy";
+    "clippy" == Ident::invalid().to_string();
+}
diff --git a/tests/ui-internal/unnecessary_symbol_str.stderr b/tests/ui-internal/unnecessary_symbol_str.stderr
new file mode 100644
index 0000000000000..b1284b7c8ffd0
--- /dev/null
+++ b/tests/ui-internal/unnecessary_symbol_str.stderr
@@ -0,0 +1,39 @@
+error: unnecessary `Symbol` to string conversion
+  --> $DIR/unnecessary_symbol_str.rs:11:5
+   |
+LL |     Symbol::intern("foo").as_str() == "clippy";
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Symbol::intern("foo") == rustc_span::sym::clippy`
+   |
+note: the lint level is defined here
+  --> $DIR/unnecessary_symbol_str.rs:3:9
+   |
+LL | #![deny(clippy::internal)]
+   |         ^^^^^^^^^^^^^^^^
+   = note: `#[deny(clippy::unnecessary_symbol_str)]` implied by `#[deny(clippy::internal)]`
+
+error: unnecessary `Symbol` to string conversion
+  --> $DIR/unnecessary_symbol_str.rs:12:5
+   |
+LL |     Symbol::intern("foo").to_string() == "self";
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Symbol::intern("foo") == rustc_span::symbol::kw::SelfLower`
+
+error: unnecessary `Symbol` to string conversion
+  --> $DIR/unnecessary_symbol_str.rs:13:5
+   |
+LL |     Symbol::intern("foo").to_ident_string() != "Self";
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Symbol::intern("foo") != rustc_span::symbol::kw::SelfUpper`
+
+error: unnecessary `Symbol` to string conversion
+  --> $DIR/unnecessary_symbol_str.rs:14:5
+   |
+LL |     &*Ident::invalid().as_str() == "clippy";
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Ident::invalid().name == rustc_span::sym::clippy`
+
+error: unnecessary `Symbol` to string conversion
+  --> $DIR/unnecessary_symbol_str.rs:15:5
+   |
+LL |     "clippy" == Ident::invalid().to_string();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `rustc_span::sym::clippy == Ident::invalid().name`
+
+error: aborting due to 5 previous errors
+
diff --git a/tests/ui/auxiliary/macro_rules.rs b/tests/ui/auxiliary/macro_rules.rs
index 1832482346820..d6ecd8568ce78 100644
--- a/tests/ui/auxiliary/macro_rules.rs
+++ b/tests/ui/auxiliary/macro_rules.rs
@@ -94,3 +94,19 @@ macro_rules! large_enum_variant {
         }
     };
 }
+
+#[macro_export]
+macro_rules! field_reassign_with_default {
+    () => {
+        #[derive(Default)]
+        struct A {
+            pub i: i32,
+            pub j: i64,
+        }
+        fn lint() {
+            let mut a: A = Default::default();
+            a.i = 42;
+            a;
+        }
+    };
+}
diff --git a/tests/ui/auxiliary/proc_macro_derive.rs b/tests/ui/auxiliary/proc_macro_derive.rs
index 7c4e4a145512f..24891682d368d 100644
--- a/tests/ui/auxiliary/proc_macro_derive.rs
+++ b/tests/ui/auxiliary/proc_macro_derive.rs
@@ -4,6 +4,7 @@
 #![crate_type = "proc-macro"]
 #![feature(repr128, proc_macro_quote)]
 #![allow(incomplete_features)]
+#![allow(clippy::field_reassign_with_default)]
 #![allow(clippy::eq_op)]
 
 extern crate proc_macro;
@@ -23,3 +24,20 @@ pub fn derive(_: TokenStream) -> TokenStream {
     };
     output
 }
+
+#[proc_macro_derive(FieldReassignWithDefault)]
+pub fn derive_foo(_input: TokenStream) -> TokenStream {
+    quote! {
+        #[derive(Default)]
+        struct A {
+            pub i: i32,
+            pub j: i64,
+        }
+        #[automatically_derived]
+        fn lint() {
+            let mut a: A = Default::default();
+            a.i = 42;
+            a;
+        }
+    }
+}
diff --git a/tests/ui/cast_alignment.rs b/tests/ui/cast_alignment.rs
index 4c08935639f1f..d011e84b115a7 100644
--- a/tests/ui/cast_alignment.rs
+++ b/tests/ui/cast_alignment.rs
@@ -12,6 +12,10 @@ fn main() {
     (&1u8 as *const u8) as *const u16;
     (&mut 1u8 as *mut u8) as *mut u16;
 
+    // cast to more-strictly-aligned type, but with the `pointer::cast` function.
+    (&1u8 as *const u8).cast::<u16>();
+    (&mut 1u8 as *mut u8).cast::<u16>();
+
     /* These should be ok */
 
     // not a pointer type
diff --git a/tests/ui/cast_alignment.stderr b/tests/ui/cast_alignment.stderr
index 79219f86155a4..7998b787b91fb 100644
--- a/tests/ui/cast_alignment.stderr
+++ b/tests/ui/cast_alignment.stderr
@@ -12,5 +12,17 @@ error: casting from `*mut u8` to a more-strictly-aligned pointer (`*mut u16`) (1
 LL |     (&mut 1u8 as *mut u8) as *mut u16;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 2 previous errors
+error: casting from `*const u8` to a more-strictly-aligned pointer (`*const u16`) (1 < 2 bytes)
+  --> $DIR/cast_alignment.rs:16:5
+   |
+LL |     (&1u8 as *const u8).cast::<u16>();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: casting from `*mut u8` to a more-strictly-aligned pointer (`*mut u16`) (1 < 2 bytes)
+  --> $DIR/cast_alignment.rs:17:5
+   |
+LL |     (&mut 1u8 as *mut u8).cast::<u16>();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 4 previous errors
 
diff --git a/tests/ui/clone_on_copy.fixed b/tests/ui/clone_on_copy.fixed
index 1f0ca101757ec..d924625132eb0 100644
--- a/tests/ui/clone_on_copy.fixed
+++ b/tests/ui/clone_on_copy.fixed
@@ -5,7 +5,8 @@
     clippy::redundant_clone,
     clippy::deref_addrof,
     clippy::no_effect,
-    clippy::unnecessary_operation
+    clippy::unnecessary_operation,
+    clippy::vec_init_then_push
 )]
 
 use std::cell::RefCell;
diff --git a/tests/ui/clone_on_copy.rs b/tests/ui/clone_on_copy.rs
index ca39a654b4fce..97f4946724458 100644
--- a/tests/ui/clone_on_copy.rs
+++ b/tests/ui/clone_on_copy.rs
@@ -5,7 +5,8 @@
     clippy::redundant_clone,
     clippy::deref_addrof,
     clippy::no_effect,
-    clippy::unnecessary_operation
+    clippy::unnecessary_operation,
+    clippy::vec_init_then_push
 )]
 
 use std::cell::RefCell;
diff --git a/tests/ui/clone_on_copy.stderr b/tests/ui/clone_on_copy.stderr
index 14a700886a7bc..7a706884fb0e7 100644
--- a/tests/ui/clone_on_copy.stderr
+++ b/tests/ui/clone_on_copy.stderr
@@ -1,5 +1,5 @@
 error: using `clone` on type `i32` which implements the `Copy` trait
-  --> $DIR/clone_on_copy.rs:22:5
+  --> $DIR/clone_on_copy.rs:23:5
    |
 LL |     42.clone();
    |     ^^^^^^^^^^ help: try removing the `clone` call: `42`
@@ -7,25 +7,25 @@ LL |     42.clone();
    = note: `-D clippy::clone-on-copy` implied by `-D warnings`
 
 error: using `clone` on type `i32` which implements the `Copy` trait
-  --> $DIR/clone_on_copy.rs:26:5
+  --> $DIR/clone_on_copy.rs:27:5
    |
 LL |     (&42).clone();
    |     ^^^^^^^^^^^^^ help: try dereferencing it: `*(&42)`
 
 error: using `clone` on type `i32` which implements the `Copy` trait
-  --> $DIR/clone_on_copy.rs:29:5
+  --> $DIR/clone_on_copy.rs:30:5
    |
 LL |     rc.borrow().clone();
    |     ^^^^^^^^^^^^^^^^^^^ help: try dereferencing it: `*rc.borrow()`
 
 error: using `clone` on type `char` which implements the `Copy` trait
-  --> $DIR/clone_on_copy.rs:35:14
+  --> $DIR/clone_on_copy.rs:36:14
    |
 LL |     is_ascii('z'.clone());
    |              ^^^^^^^^^^^ help: try removing the `clone` call: `'z'`
 
 error: using `clone` on type `i32` which implements the `Copy` trait
-  --> $DIR/clone_on_copy.rs:39:14
+  --> $DIR/clone_on_copy.rs:40:14
    |
 LL |     vec.push(42.clone());
    |              ^^^^^^^^^^ help: try removing the `clone` call: `42`
diff --git a/tests/ui/collapsible_else_if.fixed b/tests/ui/collapsible_else_if.fixed
index ce2a1c28c8a80..fa4bc30e933a2 100644
--- a/tests/ui/collapsible_else_if.fixed
+++ b/tests/ui/collapsible_else_if.fixed
@@ -3,6 +3,8 @@
 
 #[rustfmt::skip]
 #[warn(clippy::collapsible_if)]
+#[warn(clippy::collapsible_else_if)]
+
 fn main() {
     let x = "hello";
     let y = "world";
diff --git a/tests/ui/collapsible_else_if.rs b/tests/ui/collapsible_else_if.rs
index 99c40b8d38eb9..bf6c1d1f894d7 100644
--- a/tests/ui/collapsible_else_if.rs
+++ b/tests/ui/collapsible_else_if.rs
@@ -3,6 +3,8 @@
 
 #[rustfmt::skip]
 #[warn(clippy::collapsible_if)]
+#[warn(clippy::collapsible_else_if)]
+
 fn main() {
     let x = "hello";
     let y = "world";
diff --git a/tests/ui/collapsible_else_if.stderr b/tests/ui/collapsible_else_if.stderr
index 3d1c458879e58..ee3e11ae565d4 100644
--- a/tests/ui/collapsible_else_if.stderr
+++ b/tests/ui/collapsible_else_if.stderr
@@ -1,5 +1,5 @@
 error: this `else { if .. }` block can be collapsed
-  --> $DIR/collapsible_else_if.rs:12:12
+  --> $DIR/collapsible_else_if.rs:14:12
    |
 LL |       } else {
    |  ____________^
@@ -9,7 +9,7 @@ LL | |         }
 LL | |     }
    | |_____^
    |
-   = note: `-D clippy::collapsible-if` implied by `-D warnings`
+   = note: `-D clippy::collapsible-else-if` implied by `-D warnings`
 help: collapse nested if block
    |
 LL |     } else if y == "world" {
@@ -18,7 +18,7 @@ LL |     }
    |
 
 error: this `else { if .. }` block can be collapsed
-  --> $DIR/collapsible_else_if.rs:20:12
+  --> $DIR/collapsible_else_if.rs:22:12
    |
 LL |       } else {
    |  ____________^
@@ -36,7 +36,7 @@ LL |     }
    |
 
 error: this `else { if .. }` block can be collapsed
-  --> $DIR/collapsible_else_if.rs:28:12
+  --> $DIR/collapsible_else_if.rs:30:12
    |
 LL |       } else {
    |  ____________^
@@ -59,7 +59,7 @@ LL |     }
    |
 
 error: this `else { if .. }` block can be collapsed
-  --> $DIR/collapsible_else_if.rs:39:12
+  --> $DIR/collapsible_else_if.rs:41:12
    |
 LL |       } else {
    |  ____________^
@@ -82,7 +82,7 @@ LL |     }
    |
 
 error: this `else { if .. }` block can be collapsed
-  --> $DIR/collapsible_else_if.rs:50:12
+  --> $DIR/collapsible_else_if.rs:52:12
    |
 LL |       } else {
    |  ____________^
@@ -105,7 +105,7 @@ LL |     }
    |
 
 error: this `else { if .. }` block can be collapsed
-  --> $DIR/collapsible_else_if.rs:61:12
+  --> $DIR/collapsible_else_if.rs:63:12
    |
 LL |       } else {
    |  ____________^
@@ -128,7 +128,7 @@ LL |     }
    |
 
 error: this `else { if .. }` block can be collapsed
-  --> $DIR/collapsible_else_if.rs:72:12
+  --> $DIR/collapsible_else_if.rs:74:12
    |
 LL |       } else {
    |  ____________^
diff --git a/tests/ui/empty_enum.rs b/tests/ui/empty_enum.rs
index 12428f29625c0..a2e5c13c45282 100644
--- a/tests/ui/empty_enum.rs
+++ b/tests/ui/empty_enum.rs
@@ -1,6 +1,7 @@
 #![allow(dead_code)]
 #![warn(clippy::empty_enum)]
-
+// Enable never type to test empty enum lint
+#![feature(never_type)]
 enum Empty {}
 
 fn main() {}
diff --git a/tests/ui/empty_enum.stderr b/tests/ui/empty_enum.stderr
index 466dfbe7cee7a..7125e5f602b75 100644
--- a/tests/ui/empty_enum.stderr
+++ b/tests/ui/empty_enum.stderr
@@ -1,5 +1,5 @@
 error: enum with no variants
-  --> $DIR/empty_enum.rs:4:1
+  --> $DIR/empty_enum.rs:5:1
    |
 LL | enum Empty {}
    | ^^^^^^^^^^^^^
diff --git a/tests/ui/empty_enum_without_never_type.rs b/tests/ui/empty_enum_without_never_type.rs
new file mode 100644
index 0000000000000..386677352e29b
--- /dev/null
+++ b/tests/ui/empty_enum_without_never_type.rs
@@ -0,0 +1,7 @@
+#![allow(dead_code)]
+#![warn(clippy::empty_enum)]
+
+// `never_type` is not enabled; this test has no stderr file
+enum Empty {}
+
+fn main() {}
diff --git a/tests/ui/escape_analysis.rs b/tests/ui/escape_analysis.rs
index 07004489610d0..d26f48fc68f85 100644
--- a/tests/ui/escape_analysis.rs
+++ b/tests/ui/escape_analysis.rs
@@ -182,3 +182,23 @@ pub extern "C" fn do_not_warn_me(_c_pointer: Box<String>) -> () {}
 
 #[rustfmt::skip] // Forces rustfmt to not add ABI
 pub extern fn do_not_warn_me_no_abi(_c_pointer: Box<String>) -> () {}
+
+// Issue #4804 - default implementation in trait
+mod issue4804 {
+    trait DefaultTraitImplTest {
+        // don't warn on `self`
+        fn default_impl(self: Box<Self>) -> u32 {
+            5
+        }
+
+        // warn on `x: Box<u32>`
+        fn default_impl_x(self: Box<Self>, x: Box<u32>) -> u32 {
+            4
+        }
+    }
+
+    trait WarnTrait {
+        // warn on `x: Box<u32>`
+        fn foo(x: Box<u32>) {}
+    }
+}
diff --git a/tests/ui/escape_analysis.stderr b/tests/ui/escape_analysis.stderr
index c86a769a3da4b..4a82b4419f997 100644
--- a/tests/ui/escape_analysis.stderr
+++ b/tests/ui/escape_analysis.stderr
@@ -12,5 +12,17 @@ error: local variable doesn't need to be boxed here
 LL | pub fn new(_needs_name: Box<PeekableSeekable<&()>>) -> () {}
    |            ^^^^^^^^^^^
 
-error: aborting due to 2 previous errors
+error: local variable doesn't need to be boxed here
+  --> $DIR/escape_analysis.rs:195:44
+   |
+LL |         fn default_impl_x(self: Box<Self>, x: Box<u32>) -> u32 {
+   |                                            ^
+
+error: local variable doesn't need to be boxed here
+  --> $DIR/escape_analysis.rs:202:16
+   |
+LL |         fn foo(x: Box<u32>) {}
+   |                ^
+
+error: aborting due to 4 previous errors
 
diff --git a/tests/ui/field_reassign_with_default.rs b/tests/ui/field_reassign_with_default.rs
index 3e0921022b417..9fc208f5332a5 100644
--- a/tests/ui/field_reassign_with_default.rs
+++ b/tests/ui/field_reassign_with_default.rs
@@ -1,5 +1,18 @@
+// aux-build:proc_macro_derive.rs
+// aux-build:macro_rules.rs
+
 #![warn(clippy::field_reassign_with_default)]
 
+#[macro_use]
+extern crate proc_macro_derive;
+#[macro_use]
+extern crate macro_rules;
+
+// Don't lint on derives that derive `Default`
+// See https://github.com/rust-lang/rust-clippy/issues/6545
+#[derive(FieldReassignWithDefault)]
+struct DerivedStruct;
+
 #[derive(Default)]
 struct A {
     i: i32,
@@ -11,6 +24,11 @@ struct B {
     j: i64,
 }
 
+#[derive(Default)]
+struct C {
+    i: Vec<i32>,
+    j: i64,
+}
 /// Implements .next() that returns a different number each time.
 struct SideEffect(i32);
 
@@ -111,6 +129,13 @@ fn main() {
     // don't lint - some private fields
     let mut x = m::F::default();
     x.a = 1;
+
+    // don't expand macros in the suggestion (#6522)
+    let mut a: C = C::default();
+    a.i = vec![1];
+
+    // Don't lint in external macros
+    field_reassign_with_default!();
 }
 
 mod m {
diff --git a/tests/ui/field_reassign_with_default.stderr b/tests/ui/field_reassign_with_default.stderr
index 9a2bc778c3ff7..2f0f28f7bb724 100644
--- a/tests/ui/field_reassign_with_default.stderr
+++ b/tests/ui/field_reassign_with_default.stderr
@@ -1,75 +1,87 @@
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> $DIR/field_reassign_with_default.rs:30:5
+  --> $DIR/field_reassign_with_default.rs:48:5
    |
 LL |     a.i = 42;
    |     ^^^^^^^^^
    |
    = note: `-D clippy::field-reassign-with-default` implied by `-D warnings`
-note: consider initializing the variable with `A { i: 42, ..Default::default() }` and removing relevant reassignments
-  --> $DIR/field_reassign_with_default.rs:29:5
+note: consider initializing the variable with `main::A { i: 42, ..Default::default() }` and removing relevant reassignments
+  --> $DIR/field_reassign_with_default.rs:47:5
    |
 LL |     let mut a: A = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> $DIR/field_reassign_with_default.rs:70:5
+  --> $DIR/field_reassign_with_default.rs:88:5
    |
 LL |     a.j = 43;
    |     ^^^^^^^^^
    |
-note: consider initializing the variable with `A { j: 43, i: 42 }` and removing relevant reassignments
-  --> $DIR/field_reassign_with_default.rs:69:5
+note: consider initializing the variable with `main::A { j: 43, i: 42 }` and removing relevant reassignments
+  --> $DIR/field_reassign_with_default.rs:87:5
    |
 LL |     let mut a: A = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> $DIR/field_reassign_with_default.rs:75:5
+  --> $DIR/field_reassign_with_default.rs:93:5
    |
 LL |     a.i = 42;
    |     ^^^^^^^^^
    |
-note: consider initializing the variable with `A { i: 42, j: 44 }` and removing relevant reassignments
-  --> $DIR/field_reassign_with_default.rs:74:5
+note: consider initializing the variable with `main::A { i: 42, j: 44 }` and removing relevant reassignments
+  --> $DIR/field_reassign_with_default.rs:92:5
    |
 LL |     let mut a: A = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> $DIR/field_reassign_with_default.rs:81:5
+  --> $DIR/field_reassign_with_default.rs:99:5
    |
 LL |     a.i = 42;
    |     ^^^^^^^^^
    |
-note: consider initializing the variable with `A { i: 42, ..Default::default() }` and removing relevant reassignments
-  --> $DIR/field_reassign_with_default.rs:80:5
+note: consider initializing the variable with `main::A { i: 42, ..Default::default() }` and removing relevant reassignments
+  --> $DIR/field_reassign_with_default.rs:98:5
    |
 LL |     let mut a = A::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> $DIR/field_reassign_with_default.rs:91:5
+  --> $DIR/field_reassign_with_default.rs:109:5
    |
 LL |     a.i = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: consider initializing the variable with `A { i: Default::default(), ..Default::default() }` and removing relevant reassignments
-  --> $DIR/field_reassign_with_default.rs:90:5
+note: consider initializing the variable with `main::A { i: Default::default(), ..Default::default() }` and removing relevant reassignments
+  --> $DIR/field_reassign_with_default.rs:108:5
    |
 LL |     let mut a: A = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> $DIR/field_reassign_with_default.rs:95:5
+  --> $DIR/field_reassign_with_default.rs:113:5
    |
 LL |     a.i = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: consider initializing the variable with `A { i: Default::default(), j: 45 }` and removing relevant reassignments
-  --> $DIR/field_reassign_with_default.rs:94:5
+note: consider initializing the variable with `main::A { i: Default::default(), j: 45 }` and removing relevant reassignments
+  --> $DIR/field_reassign_with_default.rs:112:5
    |
 LL |     let mut a: A = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 6 previous errors
+error: field assignment outside of initializer for an instance created with Default::default()
+  --> $DIR/field_reassign_with_default.rs:135:5
+   |
+LL |     a.i = vec![1];
+   |     ^^^^^^^^^^^^^^
+   |
+note: consider initializing the variable with `C { i: vec![1], ..Default::default() }` and removing relevant reassignments
+  --> $DIR/field_reassign_with_default.rs:134:5
+   |
+LL |     let mut a: C = C::default();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 7 previous errors
 
diff --git a/tests/ui/from_over_into.stderr b/tests/ui/from_over_into.stderr
index 18f56f854329e..b101d2704fbda 100644
--- a/tests/ui/from_over_into.stderr
+++ b/tests/ui/from_over_into.stderr
@@ -1,12 +1,8 @@
 error: an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true
   --> $DIR/from_over_into.rs:6:1
    |
-LL | / impl Into<StringWrapper> for String {
-LL | |     fn into(self) -> StringWrapper {
-LL | |         StringWrapper(self)
-LL | |     }
-LL | | }
-   | |_^
+LL | impl Into<StringWrapper> for String {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::from-over-into` implied by `-D warnings`
    = help: consider to implement `From` instead
diff --git a/tests/ui/if_same_then_else2.rs b/tests/ui/if_same_then_else2.rs
index 8d54f75b5d19f..e83ce47e56308 100644
--- a/tests/ui/if_same_then_else2.rs
+++ b/tests/ui/if_same_then_else2.rs
@@ -1,6 +1,7 @@
 #![warn(clippy::if_same_then_else)]
 #![allow(
     clippy::blacklisted_name,
+    clippy::collapsible_else_if,
     clippy::collapsible_if,
     clippy::ifs_same_cond,
     clippy::needless_return,
diff --git a/tests/ui/if_same_then_else2.stderr b/tests/ui/if_same_then_else2.stderr
index da2be6c8aa5ac..f98e30fa376fe 100644
--- a/tests/ui/if_same_then_else2.stderr
+++ b/tests/ui/if_same_then_else2.stderr
@@ -1,5 +1,5 @@
 error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:20:12
+  --> $DIR/if_same_then_else2.rs:21:12
    |
 LL |       } else {
    |  ____________^
@@ -13,7 +13,7 @@ LL | |     }
    |
    = note: `-D clippy::if-same-then-else` implied by `-D warnings`
 note: same as this
-  --> $DIR/if_same_then_else2.rs:11:13
+  --> $DIR/if_same_then_else2.rs:12:13
    |
 LL |       if true {
    |  _____________^
@@ -26,7 +26,7 @@ LL | |     } else {
    | |_____^
 
 error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:34:12
+  --> $DIR/if_same_then_else2.rs:35:12
    |
 LL |       } else {
    |  ____________^
@@ -36,7 +36,7 @@ LL | |     }
    | |_____^
    |
 note: same as this
-  --> $DIR/if_same_then_else2.rs:32:13
+  --> $DIR/if_same_then_else2.rs:33:13
    |
 LL |       if true {
    |  _____________^
@@ -45,7 +45,7 @@ LL | |     } else {
    | |_____^
 
 error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:41:12
+  --> $DIR/if_same_then_else2.rs:42:12
    |
 LL |       } else {
    |  ____________^
@@ -55,7 +55,7 @@ LL | |     }
    | |_____^
    |
 note: same as this
-  --> $DIR/if_same_then_else2.rs:39:13
+  --> $DIR/if_same_then_else2.rs:40:13
    |
 LL |       if true {
    |  _____________^
@@ -64,7 +64,7 @@ LL | |     } else {
    | |_____^
 
 error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:91:12
+  --> $DIR/if_same_then_else2.rs:92:12
    |
 LL |       } else {
    |  ____________^
@@ -74,7 +74,7 @@ LL | |     };
    | |_____^
    |
 note: same as this
-  --> $DIR/if_same_then_else2.rs:89:21
+  --> $DIR/if_same_then_else2.rs:90:21
    |
 LL |       let _ = if true {
    |  _____________________^
@@ -83,7 +83,7 @@ LL | |     } else {
    | |_____^
 
 error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:98:12
+  --> $DIR/if_same_then_else2.rs:99:12
    |
 LL |       } else {
    |  ____________^
@@ -93,7 +93,7 @@ LL | |     }
    | |_____^
    |
 note: same as this
-  --> $DIR/if_same_then_else2.rs:96:13
+  --> $DIR/if_same_then_else2.rs:97:13
    |
 LL |       if true {
    |  _____________^
@@ -102,7 +102,7 @@ LL | |     } else {
    | |_____^
 
 error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:123:12
+  --> $DIR/if_same_then_else2.rs:124:12
    |
 LL |       } else {
    |  ____________^
@@ -112,7 +112,7 @@ LL | |     }
    | |_____^
    |
 note: same as this
-  --> $DIR/if_same_then_else2.rs:120:20
+  --> $DIR/if_same_then_else2.rs:121:20
    |
 LL |       } else if true {
    |  ____________________^
diff --git a/tests/ui/needless_question_mark.fixed b/tests/ui/needless_question_mark.fixed
new file mode 100644
index 0000000000000..70218f3f041d8
--- /dev/null
+++ b/tests/ui/needless_question_mark.fixed
@@ -0,0 +1,163 @@
+// run-rustfix
+
+#![warn(clippy::needless_question_mark)]
+#![allow(clippy::needless_return, clippy::unnecessary_unwrap, dead_code, unused_must_use)]
+#![feature(custom_inner_attributes)]
+
+struct TO {
+    magic: Option<usize>,
+}
+
+struct TR {
+    magic: Result<usize, bool>,
+}
+
+fn simple_option_bad1(to: TO) -> Option<usize> {
+    // return as a statement
+    return to.magic;
+}
+
+// formatting will add a semi-colon, which would make
+// this identical to the test case above
+#[rustfmt::skip]
+fn simple_option_bad2(to: TO) -> Option<usize> {
+    // return as an expression
+    return to.magic
+}
+
+fn simple_option_bad3(to: TO) -> Option<usize> {
+    // block value "return"
+    to.magic
+}
+
+fn simple_option_bad4(to: Option<TO>) -> Option<usize> {
+    // single line closure
+    to.and_then(|t| t.magic)
+}
+
+// formatting this will remove the block brackets, making
+// this test identical to the one above
+#[rustfmt::skip]
+fn simple_option_bad5(to: Option<TO>) -> Option<usize> {
+    // closure with body
+    to.and_then(|t| {
+        t.magic
+    })
+}
+
+fn simple_result_bad1(tr: TR) -> Result<usize, bool> {
+    return tr.magic;
+}
+
+// formatting will add a semi-colon, which would make
+// this identical to the test case above
+#[rustfmt::skip]
+fn simple_result_bad2(tr: TR) -> Result<usize, bool> {
+    return tr.magic
+}
+
+fn simple_result_bad3(tr: TR) -> Result<usize, bool> {
+    tr.magic
+}
+
+fn simple_result_bad4(tr: Result<TR, bool>) -> Result<usize, bool> {
+    tr.and_then(|t| t.magic)
+}
+
+// formatting this will remove the block brackets, making
+// this test identical to the one above
+#[rustfmt::skip]
+fn simple_result_bad5(tr: Result<TR, bool>) -> Result<usize, bool> {
+    tr.and_then(|t| {
+        t.magic
+    })
+}
+
+fn also_bad(tr: Result<TR, bool>) -> Result<usize, bool> {
+    if tr.is_ok() {
+        let t = tr.unwrap();
+        return t.magic;
+    }
+    Err(false)
+}
+
+fn false_positive_test<U, T>(x: Result<(), U>) -> Result<(), T>
+where
+    T: From<U>,
+{
+    Ok(x?)
+}
+
+fn main() {}
+
+mod question_mark_none {
+    #![clippy::msrv = "1.12.0"]
+    fn needless_question_mark_option() -> Option<usize> {
+        struct TO {
+            magic: Option<usize>,
+        }
+        let to = TO { magic: None };
+        Some(to.magic?) // should not be triggered
+    }
+
+    fn needless_question_mark_result() -> Result<usize, bool> {
+        struct TO {
+            magic: Result<usize, bool>,
+        }
+        let to = TO { magic: Ok(1_usize) };
+        Ok(to.magic?) // should not be triggered
+    }
+
+    fn main() {
+        needless_question_mark_option();
+        needless_question_mark_result();
+    }
+}
+
+mod question_mark_result {
+    #![clippy::msrv = "1.21.0"]
+    fn needless_question_mark_option() -> Option<usize> {
+        struct TO {
+            magic: Option<usize>,
+        }
+        let to = TO { magic: None };
+        Some(to.magic?) // should not be triggered
+    }
+
+    fn needless_question_mark_result() -> Result<usize, bool> {
+        struct TO {
+            magic: Result<usize, bool>,
+        }
+        let to = TO { magic: Ok(1_usize) };
+        to.magic // should be triggered
+    }
+
+    fn main() {
+        needless_question_mark_option();
+        needless_question_mark_result();
+    }
+}
+
+mod question_mark_both {
+    #![clippy::msrv = "1.22.0"]
+    fn needless_question_mark_option() -> Option<usize> {
+        struct TO {
+            magic: Option<usize>,
+        }
+        let to = TO { magic: None };
+        to.magic // should be triggered
+    }
+
+    fn needless_question_mark_result() -> Result<usize, bool> {
+        struct TO {
+            magic: Result<usize, bool>,
+        }
+        let to = TO { magic: Ok(1_usize) };
+        to.magic // should be triggered
+    }
+
+    fn main() {
+        needless_question_mark_option();
+        needless_question_mark_result();
+    }
+}
diff --git a/tests/ui/needless_question_mark.rs b/tests/ui/needless_question_mark.rs
new file mode 100644
index 0000000000000..60ac2c8d72eac
--- /dev/null
+++ b/tests/ui/needless_question_mark.rs
@@ -0,0 +1,163 @@
+// run-rustfix
+
+#![warn(clippy::needless_question_mark)]
+#![allow(clippy::needless_return, clippy::unnecessary_unwrap, dead_code, unused_must_use)]
+#![feature(custom_inner_attributes)]
+
+struct TO {
+    magic: Option<usize>,
+}
+
+struct TR {
+    magic: Result<usize, bool>,
+}
+
+fn simple_option_bad1(to: TO) -> Option<usize> {
+    // return as a statement
+    return Some(to.magic?);
+}
+
+// formatting will add a semi-colon, which would make
+// this identical to the test case above
+#[rustfmt::skip]
+fn simple_option_bad2(to: TO) -> Option<usize> {
+    // return as an expression
+    return Some(to.magic?)
+}
+
+fn simple_option_bad3(to: TO) -> Option<usize> {
+    // block value "return"
+    Some(to.magic?)
+}
+
+fn simple_option_bad4(to: Option<TO>) -> Option<usize> {
+    // single line closure
+    to.and_then(|t| Some(t.magic?))
+}
+
+// formatting this will remove the block brackets, making
+// this test identical to the one above
+#[rustfmt::skip]
+fn simple_option_bad5(to: Option<TO>) -> Option<usize> {
+    // closure with body
+    to.and_then(|t| {
+        Some(t.magic?)
+    })
+}
+
+fn simple_result_bad1(tr: TR) -> Result<usize, bool> {
+    return Ok(tr.magic?);
+}
+
+// formatting will add a semi-colon, which would make
+// this identical to the test case above
+#[rustfmt::skip]
+fn simple_result_bad2(tr: TR) -> Result<usize, bool> {
+    return Ok(tr.magic?)
+}
+
+fn simple_result_bad3(tr: TR) -> Result<usize, bool> {
+    Ok(tr.magic?)
+}
+
+fn simple_result_bad4(tr: Result<TR, bool>) -> Result<usize, bool> {
+    tr.and_then(|t| Ok(t.magic?))
+}
+
+// formatting this will remove the block brackets, making
+// this test identical to the one above
+#[rustfmt::skip]
+fn simple_result_bad5(tr: Result<TR, bool>) -> Result<usize, bool> {
+    tr.and_then(|t| {
+        Ok(t.magic?)
+    })
+}
+
+fn also_bad(tr: Result<TR, bool>) -> Result<usize, bool> {
+    if tr.is_ok() {
+        let t = tr.unwrap();
+        return Ok(t.magic?);
+    }
+    Err(false)
+}
+
+fn false_positive_test<U, T>(x: Result<(), U>) -> Result<(), T>
+where
+    T: From<U>,
+{
+    Ok(x?)
+}
+
+fn main() {}
+
+mod question_mark_none {
+    #![clippy::msrv = "1.12.0"]
+    fn needless_question_mark_option() -> Option<usize> {
+        struct TO {
+            magic: Option<usize>,
+        }
+        let to = TO { magic: None };
+        Some(to.magic?) // should not be triggered
+    }
+
+    fn needless_question_mark_result() -> Result<usize, bool> {
+        struct TO {
+            magic: Result<usize, bool>,
+        }
+        let to = TO { magic: Ok(1_usize) };
+        Ok(to.magic?) // should not be triggered
+    }
+
+    fn main() {
+        needless_question_mark_option();
+        needless_question_mark_result();
+    }
+}
+
+mod question_mark_result {
+    #![clippy::msrv = "1.21.0"]
+    fn needless_question_mark_option() -> Option<usize> {
+        struct TO {
+            magic: Option<usize>,
+        }
+        let to = TO { magic: None };
+        Some(to.magic?) // should not be triggered
+    }
+
+    fn needless_question_mark_result() -> Result<usize, bool> {
+        struct TO {
+            magic: Result<usize, bool>,
+        }
+        let to = TO { magic: Ok(1_usize) };
+        Ok(to.magic?) // should be triggered
+    }
+
+    fn main() {
+        needless_question_mark_option();
+        needless_question_mark_result();
+    }
+}
+
+mod question_mark_both {
+    #![clippy::msrv = "1.22.0"]
+    fn needless_question_mark_option() -> Option<usize> {
+        struct TO {
+            magic: Option<usize>,
+        }
+        let to = TO { magic: None };
+        Some(to.magic?) // should be triggered
+    }
+
+    fn needless_question_mark_result() -> Result<usize, bool> {
+        struct TO {
+            magic: Result<usize, bool>,
+        }
+        let to = TO { magic: Ok(1_usize) };
+        Ok(to.magic?) // should be triggered
+    }
+
+    fn main() {
+        needless_question_mark_option();
+        needless_question_mark_result();
+    }
+}
diff --git a/tests/ui/needless_question_mark.stderr b/tests/ui/needless_question_mark.stderr
new file mode 100644
index 0000000000000..b4eb21882ece9
--- /dev/null
+++ b/tests/ui/needless_question_mark.stderr
@@ -0,0 +1,88 @@
+error: Question mark operator is useless here
+  --> $DIR/needless_question_mark.rs:17:12
+   |
+LL |     return Some(to.magic?);
+   |            ^^^^^^^^^^^^^^^ help: try: `to.magic`
+   |
+   = note: `-D clippy::needless-question-mark` implied by `-D warnings`
+
+error: Question mark operator is useless here
+  --> $DIR/needless_question_mark.rs:25:12
+   |
+LL |     return Some(to.magic?)
+   |            ^^^^^^^^^^^^^^^ help: try: `to.magic`
+
+error: Question mark operator is useless here
+  --> $DIR/needless_question_mark.rs:30:5
+   |
+LL |     Some(to.magic?)
+   |     ^^^^^^^^^^^^^^^ help: try: `to.magic`
+
+error: Question mark operator is useless here
+  --> $DIR/needless_question_mark.rs:35:21
+   |
+LL |     to.and_then(|t| Some(t.magic?))
+   |                     ^^^^^^^^^^^^^^ help: try: `t.magic`
+
+error: Question mark operator is useless here
+  --> $DIR/needless_question_mark.rs:44:9
+   |
+LL |         Some(t.magic?)
+   |         ^^^^^^^^^^^^^^ help: try: `t.magic`
+
+error: Question mark operator is useless here
+  --> $DIR/needless_question_mark.rs:49:12
+   |
+LL |     return Ok(tr.magic?);
+   |            ^^^^^^^^^^^^^ help: try: `tr.magic`
+
+error: Question mark operator is useless here
+  --> $DIR/needless_question_mark.rs:56:12
+   |
+LL |     return Ok(tr.magic?)
+   |            ^^^^^^^^^^^^^ help: try: `tr.magic`
+
+error: Question mark operator is useless here
+  --> $DIR/needless_question_mark.rs:60:5
+   |
+LL |     Ok(tr.magic?)
+   |     ^^^^^^^^^^^^^ help: try: `tr.magic`
+
+error: Question mark operator is useless here
+  --> $DIR/needless_question_mark.rs:64:21
+   |
+LL |     tr.and_then(|t| Ok(t.magic?))
+   |                     ^^^^^^^^^^^^ help: try: `t.magic`
+
+error: Question mark operator is useless here
+  --> $DIR/needless_question_mark.rs:72:9
+   |
+LL |         Ok(t.magic?)
+   |         ^^^^^^^^^^^^ help: try: `t.magic`
+
+error: Question mark operator is useless here
+  --> $DIR/needless_question_mark.rs:79:16
+   |
+LL |         return Ok(t.magic?);
+   |                ^^^^^^^^^^^^ help: try: `t.magic`
+
+error: Question mark operator is useless here
+  --> $DIR/needless_question_mark.rs:132:9
+   |
+LL |         Ok(to.magic?) // should be triggered
+   |         ^^^^^^^^^^^^^ help: try: `to.magic`
+
+error: Question mark operator is useless here
+  --> $DIR/needless_question_mark.rs:148:9
+   |
+LL |         Some(to.magic?) // should be triggered
+   |         ^^^^^^^^^^^^^^^ help: try: `to.magic`
+
+error: Question mark operator is useless here
+  --> $DIR/needless_question_mark.rs:156:9
+   |
+LL |         Ok(to.magic?) // should be triggered
+   |         ^^^^^^^^^^^^^ help: try: `to.magic`
+
+error: aborting due to 14 previous errors
+
diff --git a/tests/ui/needless_return.fixed b/tests/ui/needless_return.fixed
index d849e093da7bb..86bfc5b4bb283 100644
--- a/tests/ui/needless_return.fixed
+++ b/tests/ui/needless_return.fixed
@@ -86,6 +86,21 @@ fn borrows_but_not_last(value: bool) -> String {
     }
 }
 
+macro_rules! needed_return {
+    ($e:expr) => {
+        if $e > 3 {
+            return;
+        }
+    };
+}
+
+fn test_return_in_macro() {
+    // This will return and the macro below won't be executed. Removing the `return` from the macro
+    // will change semantics.
+    needed_return!(10);
+    needed_return!(0);
+}
+
 fn main() {
     let _ = test_end_of_fn();
     let _ = test_no_semicolon();
diff --git a/tests/ui/needless_return.rs b/tests/ui/needless_return.rs
index 29f2bd1852af0..51061370dfe74 100644
--- a/tests/ui/needless_return.rs
+++ b/tests/ui/needless_return.rs
@@ -86,6 +86,21 @@ fn borrows_but_not_last(value: bool) -> String {
     }
 }
 
+macro_rules! needed_return {
+    ($e:expr) => {
+        if $e > 3 {
+            return;
+        }
+    };
+}
+
+fn test_return_in_macro() {
+    // This will return and the macro below won't be executed. Removing the `return` from the macro
+    // will change semantics.
+    needed_return!(10);
+    needed_return!(0);
+}
+
 fn main() {
     let _ = test_end_of_fn();
     let _ = test_no_semicolon();
diff --git a/tests/ui/ptr_as_ptr.fixed b/tests/ui/ptr_as_ptr.fixed
new file mode 100644
index 0000000000000..8346a9454f4ee
--- /dev/null
+++ b/tests/ui/ptr_as_ptr.fixed
@@ -0,0 +1,50 @@
+// run-rustfix
+
+#![warn(clippy::ptr_as_ptr)]
+#![feature(custom_inner_attributes)]
+
+fn main() {
+    let ptr: *const u32 = &42_u32;
+    let mut_ptr: *mut u32 = &mut 42_u32;
+
+    let _ = ptr.cast::<i32>();
+    let _ = mut_ptr.cast::<i32>();
+
+    // Make sure the lint can handle the difference in their operator precedences.
+    unsafe {
+        let ptr_ptr: *const *const u32 = &ptr;
+        let _ = (*ptr_ptr).cast::<i32>();
+    }
+
+    // Changes in mutability. Do not lint this.
+    let _ = ptr as *mut i32;
+    let _ = mut_ptr as *const i32;
+
+    // `pointer::cast` cannot perform unsized coercions unlike `as`. Do not lint this.
+    let ptr_of_array: *const [u32; 4] = &[1, 2, 3, 4];
+    let _ = ptr_of_array as *const [u32];
+    let _ = ptr_of_array as *const dyn std::fmt::Debug;
+
+    // Ensure the lint doesn't produce unnecessary turbofish for inferred types.
+    let _: *const i32 = ptr.cast();
+    let _: *mut i32 = mut_ptr.cast();
+}
+
+fn _msrv_1_37() {
+    #![clippy::msrv = "1.37"]
+    let ptr: *const u32 = &42_u32;
+    let mut_ptr: *mut u32 = &mut 42_u32;
+
+    // `pointer::cast` was stabilized in 1.38. Do not lint this
+    let _ = ptr as *const i32;
+    let _ = mut_ptr as *mut i32;
+}
+
+fn _msrv_1_38() {
+    #![clippy::msrv = "1.38"]
+    let ptr: *const u32 = &42_u32;
+    let mut_ptr: *mut u32 = &mut 42_u32;
+
+    let _ = ptr.cast::<i32>();
+    let _ = mut_ptr.cast::<i32>();
+}
diff --git a/tests/ui/ptr_as_ptr.rs b/tests/ui/ptr_as_ptr.rs
new file mode 100644
index 0000000000000..b68d4bc0aaca1
--- /dev/null
+++ b/tests/ui/ptr_as_ptr.rs
@@ -0,0 +1,50 @@
+// run-rustfix
+
+#![warn(clippy::ptr_as_ptr)]
+#![feature(custom_inner_attributes)]
+
+fn main() {
+    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;
+
+    // Make sure the lint can handle the difference in their operator precedences.
+    unsafe {
+        let ptr_ptr: *const *const u32 = &ptr;
+        let _ = *ptr_ptr as *const i32;
+    }
+
+    // Changes in mutability. Do not lint this.
+    let _ = ptr as *mut i32;
+    let _ = mut_ptr as *const i32;
+
+    // `pointer::cast` cannot perform unsized coercions unlike `as`. Do not lint this.
+    let ptr_of_array: *const [u32; 4] = &[1, 2, 3, 4];
+    let _ = ptr_of_array as *const [u32];
+    let _ = ptr_of_array as *const dyn std::fmt::Debug;
+
+    // Ensure the lint doesn't produce unnecessary turbofish for inferred types.
+    let _: *const i32 = ptr as *const _;
+    let _: *mut i32 = mut_ptr as _;
+}
+
+fn _msrv_1_37() {
+    #![clippy::msrv = "1.37"]
+    let ptr: *const u32 = &42_u32;
+    let mut_ptr: *mut u32 = &mut 42_u32;
+
+    // `pointer::cast` was stabilized in 1.38. Do not lint this
+    let _ = ptr as *const i32;
+    let _ = mut_ptr as *mut i32;
+}
+
+fn _msrv_1_38() {
+    #![clippy::msrv = "1.38"]
+    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;
+}
diff --git a/tests/ui/ptr_as_ptr.stderr b/tests/ui/ptr_as_ptr.stderr
new file mode 100644
index 0000000000000..854906dc111df
--- /dev/null
+++ b/tests/ui/ptr_as_ptr.stderr
@@ -0,0 +1,46 @@
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:10:13
+   |
+LL |     let _ = ptr as *const i32;
+   |             ^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `ptr.cast::<i32>()`
+   |
+   = note: `-D clippy::ptr-as-ptr` implied by `-D warnings`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:11:13
+   |
+LL |     let _ = mut_ptr as *mut i32;
+   |             ^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `mut_ptr.cast::<i32>()`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:16:17
+   |
+LL |         let _ = *ptr_ptr as *const i32;
+   |                 ^^^^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `(*ptr_ptr).cast::<i32>()`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:29:25
+   |
+LL |     let _: *const i32 = ptr as *const _;
+   |                         ^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `ptr.cast()`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:30:23
+   |
+LL |     let _: *mut i32 = mut_ptr as _;
+   |                       ^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `mut_ptr.cast()`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:48:13
+   |
+LL |     let _ = ptr as *const i32;
+   |             ^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `ptr.cast::<i32>()`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:49:13
+   |
+LL |     let _ = mut_ptr as *mut i32;
+   |             ^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `mut_ptr.cast::<i32>()`
+
+error: aborting due to 7 previous errors
+
diff --git a/tests/ui/try_err.fixed b/tests/ui/try_err.fixed
index 652b611208b73..5b96bb59c5f18 100644
--- a/tests/ui/try_err.fixed
+++ b/tests/ui/try_err.fixed
@@ -2,7 +2,7 @@
 // aux-build:macro_rules.rs
 
 #![deny(clippy::try_err)]
-#![allow(clippy::unnecessary_wraps)]
+#![allow(clippy::unnecessary_wraps, clippy::needless_question_mark)]
 
 #[macro_use]
 extern crate macro_rules;
diff --git a/tests/ui/try_err.rs b/tests/ui/try_err.rs
index 6bd479657b70b..f220d697d2cd7 100644
--- a/tests/ui/try_err.rs
+++ b/tests/ui/try_err.rs
@@ -2,7 +2,7 @@
 // aux-build:macro_rules.rs
 
 #![deny(clippy::try_err)]
-#![allow(clippy::unnecessary_wraps)]
+#![allow(clippy::unnecessary_wraps, clippy::needless_question_mark)]
 
 #[macro_use]
 extern crate macro_rules;
diff --git a/tests/ui/unit_arg.rs b/tests/ui/unit_arg.rs
index 9ad16d365094e..b6a7bc5a1cc95 100644
--- a/tests/ui/unit_arg.rs
+++ b/tests/ui/unit_arg.rs
@@ -5,7 +5,8 @@
     unused_variables,
     clippy::unused_unit,
     clippy::unnecessary_wraps,
-    clippy::or_fun_call
+    clippy::or_fun_call,
+    clippy::needless_question_mark
 )]
 
 use std::fmt::Debug;
diff --git a/tests/ui/unit_arg.stderr b/tests/ui/unit_arg.stderr
index c3a839a9bf812..094cff8c98591 100644
--- a/tests/ui/unit_arg.stderr
+++ b/tests/ui/unit_arg.stderr
@@ -1,5 +1,5 @@
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:30:5
+  --> $DIR/unit_arg.rs:31:5
    |
 LL | /     foo({
 LL | |         1;
@@ -20,7 +20,7 @@ LL |     foo(());
    |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:33:5
+  --> $DIR/unit_arg.rs:34:5
    |
 LL |     foo(foo(1));
    |     ^^^^^^^^^^^
@@ -32,7 +32,7 @@ LL |     foo(());
    |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:34:5
+  --> $DIR/unit_arg.rs:35:5
    |
 LL | /     foo({
 LL | |         foo(1);
@@ -54,7 +54,7 @@ LL |     foo(());
    |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:39:5
+  --> $DIR/unit_arg.rs:40:5
    |
 LL | /     b.bar({
 LL | |         1;
@@ -74,7 +74,7 @@ LL |     b.bar(());
    |
 
 error: passing unit values to a function
-  --> $DIR/unit_arg.rs:42:5
+  --> $DIR/unit_arg.rs:43:5
    |
 LL |     taking_multiple_units(foo(0), foo(1));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -87,7 +87,7 @@ LL |     taking_multiple_units((), ());
    |
 
 error: passing unit values to a function
-  --> $DIR/unit_arg.rs:43:5
+  --> $DIR/unit_arg.rs:44:5
    |
 LL | /     taking_multiple_units(foo(0), {
 LL | |         foo(1);
@@ -110,7 +110,7 @@ LL |     taking_multiple_units((), ());
    |
 
 error: passing unit values to a function
-  --> $DIR/unit_arg.rs:47:5
+  --> $DIR/unit_arg.rs:48:5
    |
 LL | /     taking_multiple_units(
 LL | |         {
@@ -140,7 +140,7 @@ LL |         foo(2);
  ...
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:58:13
+  --> $DIR/unit_arg.rs:59:13
    |
 LL |     None.or(Some(foo(2)));
    |             ^^^^^^^^^^^^
@@ -154,7 +154,7 @@ LL |     });
    |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:61:5
+  --> $DIR/unit_arg.rs:62:5
    |
 LL |     foo(foo(()))
    |     ^^^^^^^^^^^^
@@ -166,7 +166,7 @@ LL |     foo(())
    |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:94:5
+  --> $DIR/unit_arg.rs:95:5
    |
 LL |     Some(foo(1))
    |     ^^^^^^^^^^^^
diff --git a/tests/ui/vec_init_then_push.rs b/tests/ui/vec_init_then_push.rs
new file mode 100644
index 0000000000000..642ce5040096e
--- /dev/null
+++ b/tests/ui/vec_init_then_push.rs
@@ -0,0 +1,21 @@
+#![allow(unused_variables)]
+#![warn(clippy::vec_init_then_push)]
+
+fn main() {
+    let mut def_err: Vec<u32> = Default::default();
+    def_err.push(0);
+
+    let mut new_err = Vec::<u32>::new();
+    new_err.push(1);
+
+    let mut cap_err = Vec::with_capacity(2);
+    cap_err.push(0);
+    cap_err.push(1);
+    cap_err.push(2);
+
+    let mut cap_ok = Vec::with_capacity(10);
+    cap_ok.push(0);
+
+    new_err = Vec::new();
+    new_err.push(0);
+}
diff --git a/tests/ui/vec_init_then_push.stderr b/tests/ui/vec_init_then_push.stderr
new file mode 100644
index 0000000000000..819ed47d09919
--- /dev/null
+++ b/tests/ui/vec_init_then_push.stderr
@@ -0,0 +1,34 @@
+error: calls to `push` immediately after creation
+  --> $DIR/vec_init_then_push.rs:5:5
+   |
+LL | /     let mut def_err: Vec<u32> = Default::default();
+LL | |     def_err.push(0);
+   | |____________________^ help: consider using the `vec![]` macro: `let mut def_err: Vec<u32> = vec![..];`
+   |
+   = note: `-D clippy::vec-init-then-push` implied by `-D warnings`
+
+error: calls to `push` immediately after creation
+  --> $DIR/vec_init_then_push.rs:8:5
+   |
+LL | /     let mut new_err = Vec::<u32>::new();
+LL | |     new_err.push(1);
+   | |____________________^ help: consider using the `vec![]` macro: `let mut new_err = vec![..];`
+
+error: calls to `push` immediately after creation
+  --> $DIR/vec_init_then_push.rs:11:5
+   |
+LL | /     let mut cap_err = Vec::with_capacity(2);
+LL | |     cap_err.push(0);
+LL | |     cap_err.push(1);
+LL | |     cap_err.push(2);
+   | |____________________^ help: consider using the `vec![]` macro: `let mut cap_err = vec![..];`
+
+error: calls to `push` immediately after creation
+  --> $DIR/vec_init_then_push.rs:19:5
+   |
+LL | /     new_err = Vec::new();
+LL | |     new_err.push(0);
+   | |____________________^ help: consider using the `vec![]` macro: `new_err = vec![..];`
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/wrong_self_convention.rs b/tests/ui/wrong_self_convention.rs
index 5282eba74fd18..6cfc0fcb4cae4 100644
--- a/tests/ui/wrong_self_convention.rs
+++ b/tests/ui/wrong_self_convention.rs
@@ -94,7 +94,8 @@ mod issue6307 {
     trait T: Sized {
         fn as_i32(self) {}
         fn as_u32(&self) {}
-        fn into_i32(&self) {}
+        fn into_i32(self) {}
+        fn into_i32_ref(&self) {}
         fn into_u32(self) {}
         fn is_i32(self) {}
         fn is_u32(&self) {}
@@ -117,7 +118,32 @@ mod issue6307 {
     trait U {
         fn as_i32(self);
         fn as_u32(&self);
-        fn into_i32(&self);
+        fn into_i32(self);
+        fn into_i32_ref(&self);
+        fn into_u32(self);
+        fn is_i32(self);
+        fn is_u32(&self);
+        fn to_i32(self);
+        fn to_u32(&self);
+        fn from_i32(self);
+        // check whether the lint can be allowed at the function level
+        #[allow(clippy::wrong_self_convention)]
+        fn from_cake(self);
+
+        // test for false positives
+        fn as_(self);
+        fn into_(&self);
+        fn is_(self);
+        fn to_(self);
+        fn from_(self);
+        fn to_mut(&mut self);
+    }
+
+    trait C: Copy {
+        fn as_i32(self);
+        fn as_u32(&self);
+        fn into_i32(self);
+        fn into_i32_ref(&self);
         fn into_u32(self);
         fn is_i32(self);
         fn is_u32(&self);
diff --git a/tests/ui/wrong_self_convention.stderr b/tests/ui/wrong_self_convention.stderr
index 86467eb0fc737..32bd9075bd5e1 100644
--- a/tests/ui/wrong_self_convention.stderr
+++ b/tests/ui/wrong_self_convention.stderr
@@ -79,58 +79,70 @@ LL |         fn as_i32(self) {}
    |                   ^^^^
 
 error: methods called `into_*` usually take self by value; consider choosing a less ambiguous name
-  --> $DIR/wrong_self_convention.rs:97:21
+  --> $DIR/wrong_self_convention.rs:98:25
    |
-LL |         fn into_i32(&self) {}
-   |                     ^^^^^
+LL |         fn into_i32_ref(&self) {}
+   |                         ^^^^^
 
 error: methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name
-  --> $DIR/wrong_self_convention.rs:99:19
+  --> $DIR/wrong_self_convention.rs:100:19
    |
 LL |         fn is_i32(self) {}
    |                   ^^^^
 
 error: methods called `to_*` usually take self by reference; consider choosing a less ambiguous name
-  --> $DIR/wrong_self_convention.rs:101:19
+  --> $DIR/wrong_self_convention.rs:102:19
    |
 LL |         fn to_i32(self) {}
    |                   ^^^^
 
 error: methods called `from_*` usually take no self; consider choosing a less ambiguous name
-  --> $DIR/wrong_self_convention.rs:103:21
+  --> $DIR/wrong_self_convention.rs:104:21
    |
 LL |         fn from_i32(self) {}
    |                     ^^^^
 
 error: methods called `as_*` usually take self by reference or self by mutable reference; consider choosing a less ambiguous name
-  --> $DIR/wrong_self_convention.rs:118:19
+  --> $DIR/wrong_self_convention.rs:119:19
    |
 LL |         fn as_i32(self);
    |                   ^^^^
 
 error: methods called `into_*` usually take self by value; consider choosing a less ambiguous name
-  --> $DIR/wrong_self_convention.rs:120:21
+  --> $DIR/wrong_self_convention.rs:122:25
    |
-LL |         fn into_i32(&self);
-   |                     ^^^^^
+LL |         fn into_i32_ref(&self);
+   |                         ^^^^^
 
 error: methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name
-  --> $DIR/wrong_self_convention.rs:122:19
+  --> $DIR/wrong_self_convention.rs:124:19
    |
 LL |         fn is_i32(self);
    |                   ^^^^
 
 error: methods called `to_*` usually take self by reference; consider choosing a less ambiguous name
-  --> $DIR/wrong_self_convention.rs:124:19
+  --> $DIR/wrong_self_convention.rs:126:19
    |
 LL |         fn to_i32(self);
    |                   ^^^^
 
 error: methods called `from_*` usually take no self; consider choosing a less ambiguous name
-  --> $DIR/wrong_self_convention.rs:126:21
+  --> $DIR/wrong_self_convention.rs:128:21
+   |
+LL |         fn from_i32(self);
+   |                     ^^^^
+
+error: methods called `into_*` usually take self by value; consider choosing a less ambiguous name
+  --> $DIR/wrong_self_convention.rs:146:25
+   |
+LL |         fn into_i32_ref(&self);
+   |                         ^^^^^
+
+error: methods called `from_*` usually take no self; consider choosing a less ambiguous name
+  --> $DIR/wrong_self_convention.rs:152:21
    |
 LL |         fn from_i32(self);
    |                     ^^^^
 
-error: aborting due to 22 previous errors
+error: aborting due to 24 previous errors
 

From 8a77f63879e01525a6c2d3c0cbf43d2a7d36833b Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Fri, 15 Jan 2021 11:30:58 +0100
Subject: [PATCH 017/108] Fix formulations in label descriptions

---
 CONTRIBUTING.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index ed580e5605531..f2641a23f563b 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -315,10 +315,10 @@ an ICE in a popular crate that many other crates depend on. We don't
 want Clippy to crash on your code and we want it to be as reliable as the
 suggestions from Rust compiler errors.
 
-We have prioritization labels and sync-blocker label like below.
+We have prioritization labels and a sync-blocker label, which are described below.
 - [P-low][p-low]: Requires attention (fix/response/evaluation) by a team member but isn't urgent.
 - [P-medium][p-medium]: Should be addressed by a team member until the next sync.
-- [P-high][p-high]: Should be immediately addressed and will require a out-of-cycle sync or a backport.
+- [P-high][p-high]: Should be immediately addressed and will require an out-of-cycle sync or a backport.
 - [L-sync-blocker][l-sync-blocker]: An issue that "blocks" a sync. 
 Or rather: before the sync this should be addressed,
 e.g. by removing a lint again, so it doesn't hit beta/stable.

From 83f1abff4874a66124a6aaefec248ca4051c0d23 Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Mon, 4 Jan 2021 21:20:44 +0100
Subject: [PATCH 018/108] Fix FP with empty return for `needless_return` lint

---
 clippy_lints/src/returns.rs     | 11 ++++++++++-
 tests/ui/needless_return.fixed  | 13 +++++++++++++
 tests/ui/needless_return.rs     | 13 +++++++++++++
 tests/ui/needless_return.stderr | 20 +++++++++++++++++++-
 4 files changed, 55 insertions(+), 2 deletions(-)

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 63548d8fdb438..e438f92b136ac 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -131,7 +131,16 @@ impl<'tcx> LateLintPass<'tcx> for Return {
         _: HirId,
     ) {
         match kind {
-            FnKind::Closure(_) => check_final_expr(cx, &body.value, Some(body.value.span), RetReplacement::Empty),
+            FnKind::Closure(_) => {
+                // when returning without value in closure, replace this `return`
+                // with an empty block to prevent invalid suggestion (see #6501)
+                let replacement = if let ExprKind::Ret(None) = &body.value.kind {
+                    RetReplacement::Block
+                } else {
+                    RetReplacement::Empty
+                };
+                check_final_expr(cx, &body.value, Some(body.value.span), replacement)
+            },
             FnKind::ItemFn(..) | FnKind::Method(..) => {
                 if let ExprKind::Block(ref block, _) = body.value.kind {
                     check_block_return(cx, block);
diff --git a/tests/ui/needless_return.fixed b/tests/ui/needless_return.fixed
index 86bfc5b4bb283..f137e8ecae935 100644
--- a/tests/ui/needless_return.fixed
+++ b/tests/ui/needless_return.fixed
@@ -101,6 +101,19 @@ fn test_return_in_macro() {
     needed_return!(0);
 }
 
+mod issue6501 {
+    fn foo(bar: Result<(), ()>) {
+        bar.unwrap_or_else(|_| {})
+    }
+
+    fn test_closure() {
+        let _ = || {
+            
+        };
+        let _ = || {};
+    }
+}
+
 fn main() {
     let _ = test_end_of_fn();
     let _ = test_no_semicolon();
diff --git a/tests/ui/needless_return.rs b/tests/ui/needless_return.rs
index 51061370dfe74..d754e4d37a844 100644
--- a/tests/ui/needless_return.rs
+++ b/tests/ui/needless_return.rs
@@ -101,6 +101,19 @@ fn test_return_in_macro() {
     needed_return!(0);
 }
 
+mod issue6501 {
+    fn foo(bar: Result<(), ()>) {
+        bar.unwrap_or_else(|_| return)
+    }
+
+    fn test_closure() {
+        let _ = || {
+            return;
+        };
+        let _ = || return;
+    }
+}
+
 fn main() {
     let _ = test_end_of_fn();
     let _ = test_no_semicolon();
diff --git a/tests/ui/needless_return.stderr b/tests/ui/needless_return.stderr
index f73c833a801f3..12d94e892eda5 100644
--- a/tests/ui/needless_return.stderr
+++ b/tests/ui/needless_return.stderr
@@ -84,5 +84,23 @@ error: unneeded `return` statement
 LL |         return String::new();
    |         ^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `String::new()`
 
-error: aborting due to 14 previous errors
+error: unneeded `return` statement
+  --> $DIR/needless_return.rs:91:32
+   |
+LL |         bar.unwrap_or_else(|_| return)
+   |                                ^^^^^^ help: replace `return` with an empty block: `{}`
+
+error: unneeded `return` statement
+  --> $DIR/needless_return.rs:96:13
+   |
+LL |             return;
+   |             ^^^^^^^ help: remove `return`
+
+error: unneeded `return` statement
+  --> $DIR/needless_return.rs:98:20
+   |
+LL |         let _ = || return;
+   |                    ^^^^^^ help: replace `return` with an empty block: `{}`
+
+error: aborting due to 17 previous errors
 

From 46aa654c2d1792a42835d63f9a3dfcbffc20b758 Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Fri, 15 Jan 2021 18:58:48 +0100
Subject: [PATCH 019/108] Fix test due to recent Rustup merge

---
 tests/ui/needless_return.stderr | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/ui/needless_return.stderr b/tests/ui/needless_return.stderr
index 12d94e892eda5..d1240e161c07e 100644
--- a/tests/ui/needless_return.stderr
+++ b/tests/ui/needless_return.stderr
@@ -85,19 +85,19 @@ LL |         return String::new();
    |         ^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `String::new()`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:91:32
+  --> $DIR/needless_return.rs:106:32
    |
 LL |         bar.unwrap_or_else(|_| return)
    |                                ^^^^^^ help: replace `return` with an empty block: `{}`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:96:13
+  --> $DIR/needless_return.rs:111:13
    |
 LL |             return;
    |             ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:98:20
+  --> $DIR/needless_return.rs:113:20
    |
 LL |         let _ = || return;
    |                    ^^^^^^ help: replace `return` with an empty block: `{}`

From 837bc9906552af5da429bef4b37be588b8d2f49d Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 31 Dec 2020 11:10:13 -0500
Subject: [PATCH 020/108] Initial implementation of redundant_slicing lint

---
 CHANGELOG.md                          |  1 +
 clippy_lints/src/lib.rs               |  5 +++
 clippy_lints/src/redundant_slicing.rs | 56 +++++++++++++++++++++++++++
 tests/ui/redundant_slicing.rs         | 11 ++++++
 tests/ui/redundant_slicing.stderr     | 16 ++++++++
 5 files changed, 89 insertions(+)
 create mode 100644 clippy_lints/src/redundant_slicing.rs
 create mode 100644 tests/ui/redundant_slicing.rs
 create mode 100644 tests/ui/redundant_slicing.stderr

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b0e9ad55b4f55..85f6929f924e2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2162,6 +2162,7 @@ Released 2018-09-13
 [`redundant_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pattern
 [`redundant_pattern_matching`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pattern_matching
 [`redundant_pub_crate`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pub_crate
+[`redundant_slicing`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_slicing
 [`redundant_static_lifetimes`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_static_lifetimes
 [`ref_in_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_in_deref
 [`ref_option_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_option_ref
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 4f9ebb4af3d28..70fdfd22caa06 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -301,6 +301,7 @@ mod redundant_closure_call;
 mod redundant_else;
 mod redundant_field_names;
 mod redundant_pub_crate;
+mod redundant_slicing;
 mod redundant_static_lifetimes;
 mod ref_option_ref;
 mod reference;
@@ -849,6 +850,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &redundant_else::REDUNDANT_ELSE,
         &redundant_field_names::REDUNDANT_FIELD_NAMES,
         &redundant_pub_crate::REDUNDANT_PUB_CRATE,
+        &redundant_slicing::REDUNDANT_SLICING,
         &redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES,
         &ref_option_ref::REF_OPTION_REF,
         &reference::DEREF_ADDROF,
@@ -1229,6 +1231,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box vec_init_then_push::VecInitThenPush::default());
     store.register_late_pass(move || box types::PtrAsPtr::new(msrv));
     store.register_late_pass(|| box case_sensitive_file_extension_comparisons::CaseSensitiveFileExtensionComparisons);
+    store.register_late_pass(|| box redundant_slicing::RedundantSlicing);
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
         LintId::of(&arithmetic::FLOAT_ARITHMETIC),
@@ -1591,6 +1594,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&redundant_clone::REDUNDANT_CLONE),
         LintId::of(&redundant_closure_call::REDUNDANT_CLOSURE_CALL),
         LintId::of(&redundant_field_names::REDUNDANT_FIELD_NAMES),
+        LintId::of(&redundant_slicing::REDUNDANT_SLICING),
         LintId::of(&redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
         LintId::of(&reference::DEREF_ADDROF),
         LintId::of(&reference::REF_IN_DEREF),
@@ -1835,6 +1839,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&ptr_offset_with_cast::PTR_OFFSET_WITH_CAST),
         LintId::of(&ranges::RANGE_ZIP_WITH_LEN),
         LintId::of(&redundant_closure_call::REDUNDANT_CLOSURE_CALL),
+        LintId::of(&redundant_slicing::REDUNDANT_SLICING),
         LintId::of(&reference::DEREF_ADDROF),
         LintId::of(&reference::REF_IN_DEREF),
         LintId::of(&repeat_once::REPEAT_ONCE),
diff --git a/clippy_lints/src/redundant_slicing.rs b/clippy_lints/src/redundant_slicing.rs
new file mode 100644
index 0000000000000..686298b694320
--- /dev/null
+++ b/clippy_lints/src/redundant_slicing.rs
@@ -0,0 +1,56 @@
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, LangItem};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::TyS;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+use crate::utils::{is_type_lang_item, snippet_with_applicability, span_lint_and_sugg};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for redundant slicing expressions which use the full range, and
+    /// do not change the type.
+    ///
+    /// **Why is this bad?** It unnecessarily adds complexity to the expression.
+    ///
+    /// **Known problems:** If the type being sliced has an implementation of `Index<RangeFull>`
+    /// that actually changes anything then it can't be removed. However, this would be surprising
+    /// to people reading the code and should have a note with it.
+    ///
+    /// **Example:**
+    ///
+    /// ```ignore
+    /// fn get_slice(x: &[u32]) -> &[u32] {
+    ///     &x[..]
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```ignore
+    /// fn get_slice(x: &[u32]) -> &[u32] {
+    ///     x
+    /// }
+    /// ```
+    pub REDUNDANT_SLICING,
+    complexity,
+    "redundant slicing of the whole range of a type"
+}
+
+declare_lint_pass!(RedundantSlicing => [REDUNDANT_SLICING]);
+
+impl LateLintPass<'_> for RedundantSlicing {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if_chain! {
+            if let ExprKind::AddrOf(_, _, addressee) = expr.kind;
+            if let ExprKind::Index(indexed, range) = addressee.kind;
+            if is_type_lang_item(cx, cx.typeck_results().expr_ty_adjusted(range), LangItem::RangeFull);
+            if TyS::same_type(cx.typeck_results().expr_ty(expr), cx.typeck_results().expr_ty(indexed));
+            then {
+                let mut app = Applicability::MachineApplicable;
+                let hint = snippet_with_applicability(cx, indexed.span, "..", &mut app).into_owned();
+
+                span_lint_and_sugg(cx, REDUNDANT_SLICING, expr.span, "redundant slicing of the whole range",
+                    "use the original slice instead", hint, app);
+            }
+        }
+    }
+}
diff --git a/tests/ui/redundant_slicing.rs b/tests/ui/redundant_slicing.rs
new file mode 100644
index 0000000000000..922b8b4ce57f6
--- /dev/null
+++ b/tests/ui/redundant_slicing.rs
@@ -0,0 +1,11 @@
+#![allow(unused)]
+#![warn(clippy::redundant_slicing)]
+
+fn main() {
+    let x: &[u32] = &[0];
+    let err = &x[..];
+
+    let v = vec![0];
+    let ok = &v[..];
+    let err = &(&v[..])[..];
+}
diff --git a/tests/ui/redundant_slicing.stderr b/tests/ui/redundant_slicing.stderr
new file mode 100644
index 0000000000000..9efd6484ad0c1
--- /dev/null
+++ b/tests/ui/redundant_slicing.stderr
@@ -0,0 +1,16 @@
+error: redundant slicing of the whole range
+  --> $DIR/redundant_slicing.rs:6:15
+   |
+LL |     let err = &x[..];
+   |               ^^^^^^ help: use the original slice instead: `x`
+   |
+   = note: `-D clippy::redundant-slicing` implied by `-D warnings`
+
+error: redundant slicing of the whole range
+  --> $DIR/redundant_slicing.rs:10:15
+   |
+LL |     let err = &(&v[..])[..];
+   |               ^^^^^^^^^^^^^ help: use the original slice instead: `(&v[..])`
+
+error: aborting due to 2 previous errors
+

From 2a41d40807ccf01268c29ba64ac9ea0efe1b26f7 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 31 Dec 2020 11:42:12 -0500
Subject: [PATCH 021/108] fix new lint error

---
 clippy_lints/src/map_unit_fn.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clippy_lints/src/map_unit_fn.rs b/clippy_lints/src/map_unit_fn.rs
index e50d11a4d7175..01126e86199b4 100644
--- a/clippy_lints/src/map_unit_fn.rs
+++ b/clippy_lints/src/map_unit_fn.rs
@@ -131,7 +131,7 @@ fn reduce_unit_expression<'a>(cx: &LateContext<'_>, expr: &'a hir::Expr<'_>) ->
             Some(expr.span)
         },
         hir::ExprKind::Block(ref block, _) => {
-            match (&block.stmts[..], block.expr.as_ref()) {
+            match (block.stmts, block.expr.as_ref()) {
                 (&[], Some(inner_expr)) => {
                     // If block only contains an expression,
                     // reduce `{ X }` to `X`

From 27c0d6c14bde219bcaf72b4bcb6426f6f8650f6e Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 31 Dec 2020 12:07:24 -0500
Subject: [PATCH 022/108] don't lint external macro expansions

---
 clippy_lints/src/redundant_slicing.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/clippy_lints/src/redundant_slicing.rs b/clippy_lints/src/redundant_slicing.rs
index 686298b694320..5140b30a4734a 100644
--- a/clippy_lints/src/redundant_slicing.rs
+++ b/clippy_lints/src/redundant_slicing.rs
@@ -2,7 +2,7 @@ use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, LangItem};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::TyS;
+use rustc_middle::{lint::in_external_macro, ty::TyS};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 use crate::utils::{is_type_lang_item, snippet_with_applicability, span_lint_and_sugg};
@@ -39,6 +39,10 @@ declare_lint_pass!(RedundantSlicing => [REDUNDANT_SLICING]);
 
 impl LateLintPass<'_> for RedundantSlicing {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if in_external_macro(cx.sess, expr.span) {
+            return;
+        }
+
         if_chain! {
             if let ExprKind::AddrOf(_, _, addressee) = expr.kind;
             if let ExprKind::Index(indexed, range) = addressee.kind;

From bf028b3f4a440bc8a390837da3a3f940177de1e6 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 31 Dec 2020 14:40:07 -0500
Subject: [PATCH 023/108] fix copy-paste error

---
 clippy_lints/src/redundant_slicing.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/clippy_lints/src/redundant_slicing.rs b/clippy_lints/src/redundant_slicing.rs
index 5140b30a4734a..4478f55926621 100644
--- a/clippy_lints/src/redundant_slicing.rs
+++ b/clippy_lints/src/redundant_slicing.rs
@@ -1,7 +1,7 @@
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, LangItem};
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::{lint::in_external_macro, ty::TyS};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -39,7 +39,7 @@ declare_lint_pass!(RedundantSlicing => [REDUNDANT_SLICING]);
 
 impl LateLintPass<'_> for RedundantSlicing {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if in_external_macro(cx.sess, expr.span) {
+        if in_external_macro(cx.sess(), expr.span) {
             return;
         }
 

From 9146a77032e7d8c96ccae177c60ddb04b6159329 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 14 Jan 2021 21:38:57 +0000
Subject: [PATCH 024/108] Update clippy_lints/src/redundant_slicing.rs

Co-authored-by: Philipp Krones <hello@philkrones.com>
---
 clippy_lints/src/redundant_slicing.rs | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/clippy_lints/src/redundant_slicing.rs b/clippy_lints/src/redundant_slicing.rs
index 4478f55926621..e5ced13514f79 100644
--- a/clippy_lints/src/redundant_slicing.rs
+++ b/clippy_lints/src/redundant_slicing.rs
@@ -52,8 +52,15 @@ impl LateLintPass<'_> for RedundantSlicing {
                 let mut app = Applicability::MachineApplicable;
                 let hint = snippet_with_applicability(cx, indexed.span, "..", &mut app).into_owned();
 
-                span_lint_and_sugg(cx, REDUNDANT_SLICING, expr.span, "redundant slicing of the whole range",
-                    "use the original slice instead", hint, app);
+                span_lint_and_sugg(
+                    cx,
+                    REDUNDANT_SLICING,
+                    expr.span,
+                    "redundant slicing of the whole range",
+                    "use the original slice instead",
+                    hint,
+                    app,
+                );
             }
         }
     }

From 7449dc96c0dd44dc5b309f24346976fea086e35d Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Sat, 16 Jan 2021 17:30:31 +0100
Subject: [PATCH 025/108] Deprecate unknown_clippy_lints

This is now handled by unknown_lints
---
 clippy_lints/src/attrs.rs            | 72 +---------------------------
 clippy_lints/src/deprecated_lints.rs | 13 +++++
 clippy_lints/src/lib.rs              |  7 +--
 tests/ui/deprecated.rs               |  1 +
 tests/ui/deprecated.stderr           |  8 +++-
 tests/ui/unknown_clippy_lints.stderr | 40 +++++++++-------
 6 files changed, 50 insertions(+), 91 deletions(-)

diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 3edbe723922f8..7607394b2fe96 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -10,11 +10,10 @@ use rustc_errors::Applicability;
 use rustc_hir::{
     Block, Expr, ExprKind, ImplItem, ImplItemKind, Item, ItemKind, StmtKind, TraitFn, TraitItem, TraitItemKind,
 };
-use rustc_lint::{CheckLintNameResult, EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext};
+use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::lev_distance::find_best_match_for_name;
 use rustc_span::source_map::Span;
 use rustc_span::sym;
 use rustc_span::symbol::{Symbol, SymbolStr};
@@ -156,33 +155,6 @@ declare_clippy_lint! {
     "empty line after outer attribute"
 }
 
-declare_clippy_lint! {
-    /// **What it does:** Checks for `allow`/`warn`/`deny`/`forbid` attributes with scoped clippy
-    /// lints and if those lints exist in clippy. If there is an uppercase letter in the lint name
-    /// (not the tool name) and a lowercase version of this lint exists, it will suggest to lowercase
-    /// the lint name.
-    ///
-    /// **Why is this bad?** A lint attribute with a mistyped lint name won't have an effect.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// Bad:
-    /// ```rust
-    /// #![warn(if_not_els)]
-    /// #![deny(clippy::All)]
-    /// ```
-    ///
-    /// Good:
-    /// ```rust
-    /// #![warn(if_not_else)]
-    /// #![deny(clippy::all)]
-    /// ```
-    pub UNKNOWN_CLIPPY_LINTS,
-    style,
-    "unknown_lints for scoped Clippy lints"
-}
-
 declare_clippy_lint! {
     /// **What it does:** Checks for `warn`/`deny`/`forbid` attributes targeting the whole clippy::restriction category.
     ///
@@ -272,7 +244,6 @@ declare_lint_pass!(Attributes => [
     INLINE_ALWAYS,
     DEPRECATED_SEMVER,
     USELESS_ATTRIBUTE,
-    UNKNOWN_CLIPPY_LINTS,
     BLANKET_CLIPPY_RESTRICTION_LINTS,
 ]);
 
@@ -409,48 +380,9 @@ fn extract_clippy_lint(lint: &NestedMetaItem) -> Option<SymbolStr> {
 }
 
 fn check_clippy_lint_names(cx: &LateContext<'_>, ident: &str, items: &[NestedMetaItem]) {
-    let lint_store = cx.lints();
     for lint in items {
         if let Some(lint_name) = extract_clippy_lint(lint) {
-            if let CheckLintNameResult::Tool(Err((None, _))) = lint_store.check_lint_name(&lint_name, Some(sym::clippy))
-            {
-                span_lint_and_then(
-                    cx,
-                    UNKNOWN_CLIPPY_LINTS,
-                    lint.span(),
-                    &format!("unknown clippy lint: clippy::{}", lint_name),
-                    |diag| {
-                        let name_lower = lint_name.to_lowercase();
-                        let symbols = lint_store
-                            .get_lints()
-                            .iter()
-                            .map(|l| Symbol::intern(&l.name_lower()))
-                            .collect::<Vec<_>>();
-                        let sugg = find_best_match_for_name(
-                            &symbols,
-                            Symbol::intern(&format!("clippy::{}", name_lower)),
-                            None,
-                        );
-                        if lint_name.chars().any(char::is_uppercase)
-                            && lint_store.find_lints(&format!("clippy::{}", name_lower)).is_ok()
-                        {
-                            diag.span_suggestion(
-                                lint.span(),
-                                "lowercase the lint name",
-                                format!("clippy::{}", name_lower),
-                                Applicability::MachineApplicable,
-                            );
-                        } else if let Some(sugg) = sugg {
-                            diag.span_suggestion(
-                                lint.span(),
-                                "did you mean",
-                                sugg.to_string(),
-                                Applicability::MachineApplicable,
-                            );
-                        }
-                    },
-                );
-            } else if lint_name == "restriction" && ident != "allow" {
+            if lint_name == "restriction" && ident != "allow" {
                 span_lint_and_help(
                     cx,
                     BLANKET_CLIPPY_RESTRICTION_LINTS,
diff --git a/clippy_lints/src/deprecated_lints.rs b/clippy_lints/src/deprecated_lints.rs
index bec0c9f93a0d2..47b3cc3ad3038 100644
--- a/clippy_lints/src/deprecated_lints.rs
+++ b/clippy_lints/src/deprecated_lints.rs
@@ -163,6 +163,19 @@ declare_deprecated_lint! {
 }
 
 declare_deprecated_lint! {
+    /// **What it does:** Nothing. This lint has been deprecated.
+    ///
+    /// **Deprecation reason:** This lint has been uplifted to rustc and is now called
+    /// `panic_fmt`.
     pub PANIC_PARAMS,
     "this lint has been uplifted to rustc and is now called `panic_fmt`"
 }
+
+declare_deprecated_lint! {
+    /// **What it does:** Nothing. This lint has been deprecated.
+    ///
+    /// **Deprecation reason:** This lint has been integrated into the `unknown_lints`
+    /// rustc lint.
+    pub UNKNOWN_CLIPPY_LINTS,
+    "this lint has been integrated into the `unknown_lints` rustc lint"
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 35b057d7b6a41..aaa17561f06d3 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -500,6 +500,10 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         "clippy::panic_params",
         "this lint has been uplifted to rustc and is now called `panic_fmt`",
     );
+    store.register_removed(
+        "clippy::unknown_clippy_lints",
+        "this lint has been integrated into the `unknown_lints` rustc lint",
+    );
     // end deprecated lints, do not remove this comment, it’s used in `update_lints`
 
     // begin register lints, do not remove this comment, it’s used in `update_lints`
@@ -541,7 +545,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &attrs::EMPTY_LINE_AFTER_OUTER_ATTR,
         &attrs::INLINE_ALWAYS,
         &attrs::MISMATCHED_TARGET_OS,
-        &attrs::UNKNOWN_CLIPPY_LINTS,
         &attrs::USELESS_ATTRIBUTE,
         &await_holding_invalid::AWAIT_HOLDING_LOCK,
         &await_holding_invalid::AWAIT_HOLDING_REFCELL_REF,
@@ -1375,7 +1378,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&attrs::DEPRECATED_CFG_ATTR),
         LintId::of(&attrs::DEPRECATED_SEMVER),
         LintId::of(&attrs::MISMATCHED_TARGET_OS),
-        LintId::of(&attrs::UNKNOWN_CLIPPY_LINTS),
         LintId::of(&attrs::USELESS_ATTRIBUTE),
         LintId::of(&bit_mask::BAD_BIT_MASK),
         LintId::of(&bit_mask::INEFFECTIVE_BIT_MASK),
@@ -1650,7 +1652,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&assertions_on_constants::ASSERTIONS_ON_CONSTANTS),
         LintId::of(&assign_ops::ASSIGN_OP_PATTERN),
         LintId::of(&attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
-        LintId::of(&attrs::UNKNOWN_CLIPPY_LINTS),
         LintId::of(&blacklisted_name::BLACKLISTED_NAME),
         LintId::of(&blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
         LintId::of(&collapsible_if::COLLAPSIBLE_IF),
diff --git a/tests/ui/deprecated.rs b/tests/ui/deprecated.rs
index e1ee8dbca2c04..4a538021b98ea 100644
--- a/tests/ui/deprecated.rs
+++ b/tests/ui/deprecated.rs
@@ -9,5 +9,6 @@
 #[warn(clippy::drop_bounds)]
 #[warn(clippy::temporary_cstring_as_ptr)]
 #[warn(clippy::panic_params)]
+#[warn(clippy::unknown_clippy_lints)]
 
 fn main() {}
diff --git a/tests/ui/deprecated.stderr b/tests/ui/deprecated.stderr
index edbb891afe07b..3429317498ed6 100644
--- a/tests/ui/deprecated.stderr
+++ b/tests/ui/deprecated.stderr
@@ -66,11 +66,17 @@ error: lint `clippy::panic_params` has been removed: `this lint has been uplifte
 LL | #[warn(clippy::panic_params)]
    |        ^^^^^^^^^^^^^^^^^^^^
 
+error: lint `clippy::unknown_clippy_lints` has been removed: `this lint has been integrated into the `unknown_lints` rustc lint`
+  --> $DIR/deprecated.rs:12:8
+   |
+LL | #[warn(clippy::unknown_clippy_lints)]
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
 error: lint `clippy::unstable_as_slice` has been removed: ``Vec::as_slice` has been stabilized in 1.7`
   --> $DIR/deprecated.rs:1:8
    |
 LL | #[warn(clippy::unstable_as_slice)]
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 12 previous errors
+error: aborting due to 13 previous errors
 
diff --git a/tests/ui/unknown_clippy_lints.stderr b/tests/ui/unknown_clippy_lints.stderr
index 1b859043bb53b..94a667e589891 100644
--- a/tests/ui/unknown_clippy_lints.stderr
+++ b/tests/ui/unknown_clippy_lints.stderr
@@ -1,52 +1,58 @@
-error: unknown clippy lint: clippy::if_not_els
+error: unknown lint: `clippy::All`
+  --> $DIR/unknown_clippy_lints.rs:5:10
+   |
+LL | #![allow(clippy::All)]
+   |          ^^^^^^^^^^^ help: did you mean: `clippy::all`
+   |
+   = note: `-D unknown-lints` implied by `-D warnings`
+
+error: unknown lint: `clippy::CMP_NAN`
+  --> $DIR/unknown_clippy_lints.rs:6:9
+   |
+LL | #![warn(clippy::CMP_NAN)]
+   |         ^^^^^^^^^^^^^^^ help: did you mean: `clippy::cmp_nan`
+
+error: unknown lint: `clippy::if_not_els`
   --> $DIR/unknown_clippy_lints.rs:9:8
    |
 LL | #[warn(clippy::if_not_els)]
    |        ^^^^^^^^^^^^^^^^^^ help: did you mean: `clippy::if_not_else`
-   |
-   = note: `-D clippy::unknown-clippy-lints` implied by `-D warnings`
 
-error: unknown clippy lint: clippy::UNNecsaRy_cAst
+error: unknown lint: `clippy::UNNecsaRy_cAst`
   --> $DIR/unknown_clippy_lints.rs:10:8
    |
 LL | #[warn(clippy::UNNecsaRy_cAst)]
    |        ^^^^^^^^^^^^^^^^^^^^^^ help: did you mean: `clippy::unnecessary_cast`
 
-error: unknown clippy lint: clippy::useles_transute
+error: unknown lint: `clippy::useles_transute`
   --> $DIR/unknown_clippy_lints.rs:11:8
    |
 LL | #[warn(clippy::useles_transute)]
    |        ^^^^^^^^^^^^^^^^^^^^^^^ help: did you mean: `clippy::useless_transmute`
 
-error: unknown clippy lint: clippy::dead_cod
+error: unknown lint: `clippy::dead_cod`
   --> $DIR/unknown_clippy_lints.rs:13:8
    |
 LL | #[warn(clippy::dead_cod)]
    |        ^^^^^^^^^^^^^^^^ help: did you mean: `clippy::drop_copy`
 
-error: unknown clippy lint: clippy::unused_colle
+error: unknown lint: `clippy::unused_colle`
   --> $DIR/unknown_clippy_lints.rs:15:8
    |
 LL | #[warn(clippy::unused_colle)]
    |        ^^^^^^^^^^^^^^^^^^^^ help: did you mean: `clippy::unused_self`
 
-error: unknown clippy lint: clippy::const_static_lifetim
+error: unknown lint: `clippy::const_static_lifetim`
   --> $DIR/unknown_clippy_lints.rs:17:8
    |
 LL | #[warn(clippy::const_static_lifetim)]
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: did you mean: `clippy::redundant_static_lifetimes`
 
-error: unknown clippy lint: clippy::All
+error: unknown lint: `clippy::All`
   --> $DIR/unknown_clippy_lints.rs:5:10
    |
 LL | #![allow(clippy::All)]
-   |          ^^^^^^^^^^^ help: lowercase the lint name: `clippy::all`
-
-error: unknown clippy lint: clippy::CMP_NAN
-  --> $DIR/unknown_clippy_lints.rs:6:9
-   |
-LL | #![warn(clippy::CMP_NAN)]
-   |         ^^^^^^^^^^^^^^^ help: lowercase the lint name: `clippy::cmp_nan`
+   |          ^^^^^^^^^^^ help: did you mean: `clippy::all`
 
-error: aborting due to 8 previous errors
+error: aborting due to 9 previous errors
 

From 38e293cf5d30a1609020c034d66e5aac3b844073 Mon Sep 17 00:00:00 2001
From: Jack Huey <jack.huey@umassmed.edu>
Date: Mon, 21 Dec 2020 22:49:03 -0500
Subject: [PATCH 026/108] Remove PredicateKind::Atom

---
 clippy_lints/src/needless_pass_by_value.rs | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index a435f86bfd8d5..ad50a6a0405fc 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -115,13 +115,15 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
             .filter(|p| !p.is_global())
             .filter_map(|obligation| {
                 // Note that we do not want to deal with qualified predicates here.
-                if let ty::PredicateKind::Atom(ty::PredicateAtom::Trait(pred, _)) = obligation.predicate.kind() {
-                    if pred.def_id() == sized_trait {
-                        return None;
+                let ty::PredicateKind::ForAll(binder) = obligation.predicate.kind();
+                match binder.skip_binder() {
+                    ty::PredicateAtom::Trait(pred, _) if !binder.has_escaping_bound_vars() => {
+                        if pred.def_id() == sized_trait {
+                            return None;
+                        }
+                        Some(pred)
                     }
-                    Some(pred)
-                } else {
-                    None
+                    _ => None,
                 }
             })
             .collect::<Vec<_>>();

From 3436e21df5f728d9d784f48d0cc219737f9a222d Mon Sep 17 00:00:00 2001
From: Jack Huey <jack.huey@umassmed.edu>
Date: Wed, 23 Dec 2020 16:36:23 -0500
Subject: [PATCH 027/108] Remove PredicateKind

---
 clippy_lints/src/needless_pass_by_value.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index ad50a6a0405fc..d2a3bd3921d27 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -115,7 +115,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
             .filter(|p| !p.is_global())
             .filter_map(|obligation| {
                 // Note that we do not want to deal with qualified predicates here.
-                let ty::PredicateKind::ForAll(binder) = obligation.predicate.kind();
+                let binder = obligation.predicate.kind();
                 match binder.skip_binder() {
                     ty::PredicateAtom::Trait(pred, _) if !binder.has_escaping_bound_vars() => {
                         if pred.def_id() == sized_trait {

From f06eeaf9827895f9ad67f07c4a85669ce6a1bba7 Mon Sep 17 00:00:00 2001
From: Jack Huey <jack.huey@umassmed.edu>
Date: Mon, 4 Jan 2021 01:58:33 -0500
Subject: [PATCH 028/108] Cleanup

---
 clippy_lints/src/needless_pass_by_value.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index d2a3bd3921d27..9306b198051c2 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -115,7 +115,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
             .filter(|p| !p.is_global())
             .filter_map(|obligation| {
                 // Note that we do not want to deal with qualified predicates here.
-                let binder = obligation.predicate.kind();
+                let binder = obligation.predicate.bound_atom();
                 match binder.skip_binder() {
                     ty::PredicateAtom::Trait(pred, _) if !binder.has_escaping_bound_vars() => {
                         if pred.def_id() == sized_trait {

From 7c3b6a63ade6ead9fc35d5fc20f53ea47f4eec71 Mon Sep 17 00:00:00 2001
From: Jack Huey <jack.huey@umassmed.edu>
Date: Mon, 4 Jan 2021 15:30:22 -0500
Subject: [PATCH 029/108] Use pred not binder

---
 clippy_lints/src/needless_pass_by_value.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index 9306b198051c2..6dc5654862b68 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -117,7 +117,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
                 // Note that we do not want to deal with qualified predicates here.
                 let binder = obligation.predicate.bound_atom();
                 match binder.skip_binder() {
-                    ty::PredicateAtom::Trait(pred, _) if !binder.has_escaping_bound_vars() => {
+                    ty::PredicateAtom::Trait(pred, _) if !pred.has_escaping_bound_vars() => {
                         if pred.def_id() == sized_trait {
                             return None;
                         }

From 82569601f2355f6cb5494031afac28bec2fefb78 Mon Sep 17 00:00:00 2001
From: Jack Huey <jack.huey@umassmed.edu>
Date: Mon, 4 Jan 2021 16:50:36 -0500
Subject: [PATCH 030/108] Cleanup

---
 clippy_lints/src/needless_pass_by_value.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index 6dc5654862b68..3e87ef03832d2 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -115,8 +115,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
             .filter(|p| !p.is_global())
             .filter_map(|obligation| {
                 // Note that we do not want to deal with qualified predicates here.
-                let binder = obligation.predicate.bound_atom();
-                match binder.skip_binder() {
+                match obligation.predicate.bound_atom().skip_binder() {
                     ty::PredicateAtom::Trait(pred, _) if !pred.has_escaping_bound_vars() => {
                         if pred.def_id() == sized_trait {
                             return None;

From e73b8dcbcaefe225f1c627905d29e6060375a665 Mon Sep 17 00:00:00 2001
From: Jack Huey <jack.huey@umassmed.edu>
Date: Thu, 7 Jan 2021 11:20:28 -0500
Subject: [PATCH 031/108] Review changes

---
 clippy_lints/src/future_not_send.rs           |  4 ++--
 clippy_lints/src/methods/mod.rs               |  2 +-
 clippy_lints/src/needless_pass_by_value.rs    |  9 +++----
 clippy_lints/src/unit_return_expecting_ord.rs |  6 ++---
 clippy_lints/src/utils/mod.rs                 |  2 +-
 .../src/utils/qualify_min_const_fn.rs         | 24 +++++++++----------
 6 files changed, 22 insertions(+), 25 deletions(-)

diff --git a/clippy_lints/src/future_not_send.rs b/clippy_lints/src/future_not_send.rs
index f9697afe40525..a3a38fad9a377 100644
--- a/clippy_lints/src/future_not_send.rs
+++ b/clippy_lints/src/future_not_send.rs
@@ -4,7 +4,7 @@ use rustc_hir::{Body, FnDecl, HirId};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::subst::Subst;
-use rustc_middle::ty::{Opaque, PredicateAtom::Trait};
+use rustc_middle::ty::{Opaque, PredicateKind::Trait};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{sym, Span};
 use rustc_trait_selection::traits::error_reporting::suggestions::InferCtxtExt;
@@ -97,7 +97,7 @@ impl<'tcx> LateLintPass<'tcx> for FutureNotSend {
                                         &obligation,
                                     );
                                     if let Trait(trait_pred, _) =
-                                        obligation.predicate.skip_binders()
+                                        obligation.predicate.kind().skip_binder()
                                     {
                                         db.note(&format!(
                                             "`{}` doesn't implement `{}`",
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 6e8102790a594..f7231bba17504 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1697,7 +1697,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             if let ty::Opaque(def_id, _) = *ret_ty.kind() {
                 // one of the associated types must be Self
                 for &(predicate, _span) in cx.tcx.explicit_item_bounds(def_id) {
-                    if let ty::PredicateAtom::Projection(projection_predicate) = predicate.skip_binders() {
+                    if let ty::PredicateKind::Projection(projection_predicate) = predicate.kind().skip_binder() {
                         // walk the associated type and check for Self
                         if contains_ty(projection_predicate.ty, self_ty) {
                             return;
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index 3e87ef03832d2..3b71f1b46e2ea 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -115,13 +115,10 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
             .filter(|p| !p.is_global())
             .filter_map(|obligation| {
                 // Note that we do not want to deal with qualified predicates here.
-                match obligation.predicate.bound_atom().skip_binder() {
-                    ty::PredicateAtom::Trait(pred, _) if !pred.has_escaping_bound_vars() => {
-                        if pred.def_id() == sized_trait {
-                            return None;
-                        }
+                match obligation.predicate.kind().no_bound_vars() {
+                    Some(ty::PredicateKind::Trait(pred, _)) if pred.def_id() != sized_trait => {
                         Some(pred)
-                    }
+                    },
                     _ => None,
                 }
             })
diff --git a/clippy_lints/src/unit_return_expecting_ord.rs b/clippy_lints/src/unit_return_expecting_ord.rs
index 2501635e7ef66..c6ae8b9b59837 100644
--- a/clippy_lints/src/unit_return_expecting_ord.rs
+++ b/clippy_lints/src/unit_return_expecting_ord.rs
@@ -4,7 +4,7 @@ use rustc_hir::def_id::DefId;
 use rustc_hir::{Expr, ExprKind, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
-use rustc_middle::ty::{GenericPredicates, PredicateAtom, ProjectionPredicate, TraitPredicate};
+use rustc_middle::ty::{GenericPredicates, PredicateKind, ProjectionPredicate, TraitPredicate};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{BytePos, Span};
 
@@ -42,7 +42,7 @@ fn get_trait_predicates_for_trait_id<'tcx>(
     let mut preds = Vec::new();
     for (pred, _) in generics.predicates {
         if_chain! {
-            if let PredicateAtom::Trait(poly_trait_pred, _) = pred.skip_binders();
+            if let PredicateKind::Trait(poly_trait_pred, _) = pred.kind().skip_binder();
             let trait_pred = cx.tcx.erase_late_bound_regions(ty::Binder::bind(poly_trait_pred));
             if let Some(trait_def_id) = trait_id;
             if trait_def_id == trait_pred.trait_ref.def_id;
@@ -60,7 +60,7 @@ fn get_projection_pred<'tcx>(
     pred: TraitPredicate<'tcx>,
 ) -> Option<ProjectionPredicate<'tcx>> {
     generics.predicates.iter().find_map(|(proj_pred, _)| {
-        if let ty::PredicateAtom::Projection(proj_pred) = proj_pred.skip_binders() {
+        if let ty::PredicateKind::Projection(proj_pred) = proj_pred.kind().skip_binder() {
             let projection_pred = cx.tcx.erase_late_bound_regions(ty::Binder::bind(proj_pred));
             if projection_pred.projection_ty.substs == pred.trait_ref.substs {
                 return Some(projection_pred);
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 3e39a47f1963d..4c707c4b90446 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -1470,7 +1470,7 @@ pub fn is_must_use_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
         ty::Tuple(ref substs) => substs.types().any(|ty| is_must_use_ty(cx, ty)),
         ty::Opaque(ref def_id, _) => {
             for (predicate, _) in cx.tcx.explicit_item_bounds(*def_id) {
-                if let ty::PredicateAtom::Trait(trait_predicate, _) = predicate.skip_binders() {
+                if let ty::PredicateKind::Trait(trait_predicate, _) = predicate.kind().skip_binder() {
                     if must_use_attr(&cx.tcx.get_attrs(trait_predicate.trait_ref.def_id)).is_some() {
                         return true;
                     }
diff --git a/clippy_lints/src/utils/qualify_min_const_fn.rs b/clippy_lints/src/utils/qualify_min_const_fn.rs
index 7cb7d0a26b65e..a482017afeb13 100644
--- a/clippy_lints/src/utils/qualify_min_const_fn.rs
+++ b/clippy_lints/src/utils/qualify_min_const_fn.rs
@@ -19,18 +19,18 @@ pub fn is_min_const_fn(tcx: TyCtxt<'tcx>, body: &'a Body<'tcx>) -> McfResult {
     loop {
         let predicates = tcx.predicates_of(current);
         for (predicate, _) in predicates.predicates {
-            match predicate.skip_binders() {
-                ty::PredicateAtom::RegionOutlives(_)
-                | ty::PredicateAtom::TypeOutlives(_)
-                | ty::PredicateAtom::WellFormed(_)
-                | ty::PredicateAtom::Projection(_)
-                | ty::PredicateAtom::ConstEvaluatable(..)
-                | ty::PredicateAtom::ConstEquate(..)
-                | ty::PredicateAtom::TypeWellFormedFromEnv(..) => continue,
-                ty::PredicateAtom::ObjectSafe(_) => panic!("object safe predicate on function: {:#?}", predicate),
-                ty::PredicateAtom::ClosureKind(..) => panic!("closure kind predicate on function: {:#?}", predicate),
-                ty::PredicateAtom::Subtype(_) => panic!("subtype predicate on function: {:#?}", predicate),
-                ty::PredicateAtom::Trait(pred, _) => {
+            match predicate.kind().skip_binder() {
+                ty::PredicateKind::RegionOutlives(_)
+                | ty::PredicateKind::TypeOutlives(_)
+                | ty::PredicateKind::WellFormed(_)
+                | ty::PredicateKind::Projection(_)
+                | ty::PredicateKind::ConstEvaluatable(..)
+                | ty::PredicateKind::ConstEquate(..)
+                | ty::PredicateKind::TypeWellFormedFromEnv(..) => continue,
+                ty::PredicateKind::ObjectSafe(_) => panic!("object safe predicate on function: {:#?}", predicate),
+                ty::PredicateKind::ClosureKind(..) => panic!("closure kind predicate on function: {:#?}", predicate),
+                ty::PredicateKind::Subtype(_) => panic!("subtype predicate on function: {:#?}", predicate),
+                ty::PredicateKind::Trait(pred, _) => {
                     if Some(pred.def_id()) == tcx.lang_items().sized_trait() {
                         continue;
                     }

From 0d542b7310294a32023e935916a4d8c8f47ec1a8 Mon Sep 17 00:00:00 2001
From: pro-grammer1 <1df0d0d3-eed4-45fc-bc60-43a85079f3f9@anonaddy.me>
Date: Sun, 17 Jan 2021 08:48:37 +0000
Subject: [PATCH 032/108] Run tests/ui/update-all-references.sh and refactor
 match into matches!

---
 clippy_lints/src/write.rs | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 78d23e1e0ef43..52118a56bb65d 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -470,10 +470,7 @@ impl Write {
                 ExprKind::Assign(lhs, rhs, _) => {
                     if_chain! {
                         if let ExprKind::Lit(ref lit) = rhs.kind;
-                        if match lit.kind {
-                            LitKind::Int(_, _) | LitKind::Float(_, _) => false,
-                            _ => true,
-                        };
+                        if matches!(lit.kind, LitKind::Int(..) | LitKind::Float(..));
                         if let ExprKind::Path(_, p) = &lhs.kind;
                         then {
                             let mut all_simple = true;

From 2af642da28109c96145c7a5613ae2ec37d359448 Mon Sep 17 00:00:00 2001
From: pro-grammer1 <1df0d0d3-eed4-45fc-bc60-43a85079f3f9@anonaddy.me>
Date: Sun, 17 Jan 2021 18:01:01 +0000
Subject: [PATCH 033/108] Replace another instance of match with matches

---
 clippy_lints/src/write.rs | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 52118a56bb65d..6721639f724bb 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -443,12 +443,7 @@ impl Write {
                 return (Some(fmtstr), None);
             };
             match &token_expr.kind {
-                ExprKind::Lit(lit)
-                    if match lit.kind {
-                        LitKind::Int(_, _) | LitKind::Float(_, _) => false,
-                        _ => true,
-                    } =>
-                {
+                ExprKind::Lit(lit) if matches!(lit.kind, LitKind::Int(..) | LitKind::Float(..)) => {
                     let mut all_simple = true;
                     let mut seen = false;
                     for arg in &args {

From ab155b14a27811c29e35bea76bfbf3845bc79fdf Mon Sep 17 00:00:00 2001
From: pro-grammer1 <1df0d0d3-eed4-45fc-bc60-43a85079f3f9@anonaddy.me>
Date: Sun, 17 Jan 2021 18:21:58 +0000
Subject: [PATCH 034/108] Negate results of matches!

---
 clippy_lints/src/write.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 6721639f724bb..60a9fb59cd2a7 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -443,7 +443,7 @@ impl Write {
                 return (Some(fmtstr), None);
             };
             match &token_expr.kind {
-                ExprKind::Lit(lit) if matches!(lit.kind, LitKind::Int(..) | LitKind::Float(..)) => {
+                ExprKind::Lit(lit) if !matches!(lit.kind, LitKind::Int(..) | LitKind::Float(..)) => {
                     let mut all_simple = true;
                     let mut seen = false;
                     for arg in &args {
@@ -465,7 +465,7 @@ impl Write {
                 ExprKind::Assign(lhs, rhs, _) => {
                     if_chain! {
                         if let ExprKind::Lit(ref lit) = rhs.kind;
-                        if matches!(lit.kind, LitKind::Int(..) | LitKind::Float(..));
+                        if !matches!(lit.kind, LitKind::Int(..) | LitKind::Float(..));
                         if let ExprKind::Path(_, p) = &lhs.kind;
                         then {
                             let mut all_simple = true;

From fb2a06dcce0680dfe8d2bed542be3c55eb2e18c7 Mon Sep 17 00:00:00 2001
From: pro-grammer1 <1df0d0d3-eed4-45fc-bc60-43a85079f3f9@anonaddy.me>
Date: Sun, 17 Jan 2021 18:55:59 +0000
Subject: [PATCH 035/108] Remove numeric literals from print_literal and
 write_literal tests

---
 clippy_lints/src/write.rs        |  2 +-
 tests/ui/crashes/ice-3891.stderr |  4 +--
 tests/ui/print_literal.rs        |  3 ---
 tests/ui/print_literal.stderr    | 46 ++++++++++----------------------
 tests/ui/write_literal.rs        |  3 ---
 tests/ui/write_literal.stderr    | 46 ++++++++++----------------------
 6 files changed, 31 insertions(+), 73 deletions(-)

diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 60a9fb59cd2a7..503cb82c3e586 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -461,7 +461,7 @@ impl Write {
                         span_lint(cx, lint, token_expr.span, "literal with an empty format string");
                     }
                     idx += 1;
-                }
+                },
                 ExprKind::Assign(lhs, rhs, _) => {
                     if_chain! {
                         if let ExprKind::Lit(ref lit) = rhs.kind;
diff --git a/tests/ui/crashes/ice-3891.stderr b/tests/ui/crashes/ice-3891.stderr
index 5a285b0e71492..59469ec5891c8 100644
--- a/tests/ui/crashes/ice-3891.stderr
+++ b/tests/ui/crashes/ice-3891.stderr
@@ -1,10 +1,10 @@
-error: invalid suffix `x` for integer literal
+error: invalid suffix `x` for number literal
   --> $DIR/ice-3891.rs:2:5
    |
 LL |     1x;
    |     ^^ invalid suffix `x`
    |
-   = help: the suffix must be one of the integral types (`u32`, `isize`, etc)
+   = help: the suffix must be one of the numeric types (`u32`, `isize`, `f32`, etc.)
 
 error: aborting due to previous error
 
diff --git a/tests/ui/print_literal.rs b/tests/ui/print_literal.rs
index 40ed18e930263..0c8aecc2d8c00 100644
--- a/tests/ui/print_literal.rs
+++ b/tests/ui/print_literal.rs
@@ -19,12 +19,9 @@ fn main() {
     println!("{number:>0width$}", number = 1, width = 6);
 
     // these should throw warnings
-    println!("{} of {:b} people know binary, the other half doesn't", 1, 2);
     print!("Hello {}", "world");
     println!("Hello {} {}", world, "world");
     println!("Hello {}", "world");
-    println!("10 / 4 is {}", 2.5);
-    println!("2 + 1 = {}", 3);
 
     // positional args don't change the fact
     // that we're using a literal -- this should
diff --git a/tests/ui/print_literal.stderr b/tests/ui/print_literal.stderr
index fc502e9f71d52..692abdb305443 100644
--- a/tests/ui/print_literal.stderr
+++ b/tests/ui/print_literal.stderr
@@ -1,88 +1,70 @@
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:22:71
-   |
-LL |     println!("{} of {:b} people know binary, the other half doesn't", 1, 2);
-   |                                                                       ^
-   |
-   = note: `-D clippy::print-literal` implied by `-D warnings`
-
-error: literal with an empty format string
-  --> $DIR/print_literal.rs:23:24
+  --> $DIR/print_literal.rs:22:24
    |
 LL |     print!("Hello {}", "world");
    |                        ^^^^^^^
+   |
+   = note: `-D clippy::print-literal` implied by `-D warnings`
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:24:36
+  --> $DIR/print_literal.rs:23:36
    |
 LL |     println!("Hello {} {}", world, "world");
    |                                    ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:25:26
+  --> $DIR/print_literal.rs:24:26
    |
 LL |     println!("Hello {}", "world");
    |                          ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:26:30
-   |
-LL |     println!("10 / 4 is {}", 2.5);
-   |                              ^^^
-
-error: literal with an empty format string
-  --> $DIR/print_literal.rs:27:28
-   |
-LL |     println!("2 + 1 = {}", 3);
-   |                            ^
-
-error: literal with an empty format string
-  --> $DIR/print_literal.rs:32:25
+  --> $DIR/print_literal.rs:29:25
    |
 LL |     println!("{0} {1}", "hello", "world");
    |                         ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:32:34
+  --> $DIR/print_literal.rs:29:34
    |
 LL |     println!("{0} {1}", "hello", "world");
    |                                  ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:33:25
+  --> $DIR/print_literal.rs:30:25
    |
 LL |     println!("{1} {0}", "hello", "world");
    |                         ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:33:34
+  --> $DIR/print_literal.rs:30:34
    |
 LL |     println!("{1} {0}", "hello", "world");
    |                                  ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:36:35
+  --> $DIR/print_literal.rs:33:35
    |
 LL |     println!("{foo} {bar}", foo = "hello", bar = "world");
    |                                   ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:36:50
+  --> $DIR/print_literal.rs:33:50
    |
 LL |     println!("{foo} {bar}", foo = "hello", bar = "world");
    |                                                  ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:37:35
+  --> $DIR/print_literal.rs:34:35
    |
 LL |     println!("{bar} {foo}", foo = "hello", bar = "world");
    |                                   ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:37:50
+  --> $DIR/print_literal.rs:34:50
    |
 LL |     println!("{bar} {foo}", foo = "hello", bar = "world");
    |                                                  ^^^^^^^
 
-error: aborting due to 14 previous errors
+error: aborting due to 11 previous errors
 
diff --git a/tests/ui/write_literal.rs b/tests/ui/write_literal.rs
index d8205c5eb6700..f5de7ea71d385 100644
--- a/tests/ui/write_literal.rs
+++ b/tests/ui/write_literal.rs
@@ -24,12 +24,9 @@ fn main() {
     writeln!(&mut v, "{number:>0width$}", number = 1, width = 6);
 
     // these should throw warnings
-    writeln!(&mut v, "{} of {:b} people know binary, the other half doesn't", 1, 2);
     write!(&mut v, "Hello {}", "world");
     writeln!(&mut v, "Hello {} {}", world, "world");
     writeln!(&mut v, "Hello {}", "world");
-    writeln!(&mut v, "10 / 4 is {}", 2.5);
-    writeln!(&mut v, "2 + 1 = {}", 3);
 
     // positional args don't change the fact
     // that we're using a literal -- this should
diff --git a/tests/ui/write_literal.stderr b/tests/ui/write_literal.stderr
index 54a787fe555af..4dcaaa474a88b 100644
--- a/tests/ui/write_literal.stderr
+++ b/tests/ui/write_literal.stderr
@@ -1,88 +1,70 @@
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:27:79
-   |
-LL |     writeln!(&mut v, "{} of {:b} people know binary, the other half doesn't", 1, 2);
-   |                                                                               ^
-   |
-   = note: `-D clippy::write-literal` implied by `-D warnings`
-
-error: literal with an empty format string
-  --> $DIR/write_literal.rs:28:32
+  --> $DIR/write_literal.rs:27:32
    |
 LL |     write!(&mut v, "Hello {}", "world");
    |                                ^^^^^^^
+   |
+   = note: `-D clippy::write-literal` implied by `-D warnings`
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:29:44
+  --> $DIR/write_literal.rs:28:44
    |
 LL |     writeln!(&mut v, "Hello {} {}", world, "world");
    |                                            ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:30:34
+  --> $DIR/write_literal.rs:29:34
    |
 LL |     writeln!(&mut v, "Hello {}", "world");
    |                                  ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:31:38
-   |
-LL |     writeln!(&mut v, "10 / 4 is {}", 2.5);
-   |                                      ^^^
-
-error: literal with an empty format string
-  --> $DIR/write_literal.rs:32:36
-   |
-LL |     writeln!(&mut v, "2 + 1 = {}", 3);
-   |                                    ^
-
-error: literal with an empty format string
-  --> $DIR/write_literal.rs:37:33
+  --> $DIR/write_literal.rs:34:33
    |
 LL |     writeln!(&mut v, "{0} {1}", "hello", "world");
    |                                 ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:37:42
+  --> $DIR/write_literal.rs:34:42
    |
 LL |     writeln!(&mut v, "{0} {1}", "hello", "world");
    |                                          ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:38:33
+  --> $DIR/write_literal.rs:35:33
    |
 LL |     writeln!(&mut v, "{1} {0}", "hello", "world");
    |                                 ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:38:42
+  --> $DIR/write_literal.rs:35:42
    |
 LL |     writeln!(&mut v, "{1} {0}", "hello", "world");
    |                                          ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:41:43
+  --> $DIR/write_literal.rs:38:43
    |
 LL |     writeln!(&mut v, "{foo} {bar}", foo = "hello", bar = "world");
    |                                           ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:41:58
+  --> $DIR/write_literal.rs:38:58
    |
 LL |     writeln!(&mut v, "{foo} {bar}", foo = "hello", bar = "world");
    |                                                          ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:42:43
+  --> $DIR/write_literal.rs:39:43
    |
 LL |     writeln!(&mut v, "{bar} {foo}", foo = "hello", bar = "world");
    |                                           ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:42:58
+  --> $DIR/write_literal.rs:39:58
    |
 LL |     writeln!(&mut v, "{bar} {foo}", foo = "hello", bar = "world");
    |                                                          ^^^^^^^
 
-error: aborting due to 14 previous errors
+error: aborting due to 11 previous errors
 

From 32b2a3f944f9889fd7c5fcfb7976430d1aeb7ed4 Mon Sep 17 00:00:00 2001
From: pro-grammer1 <1df0d0d3-eed4-45fc-bc60-43a85079f3f9@anonaddy.me>
Date: Sun, 17 Jan 2021 19:21:33 +0000
Subject: [PATCH 036/108] Add numeric literals to the write_literal and
 print_literal tests that shouldn't fail

---
 tests/ui/print_literal.rs     |  3 +++
 tests/ui/print_literal.stderr | 22 +++++++++++-----------
 tests/ui/write_literal.rs     |  3 +++
 tests/ui/write_literal.stderr | 22 +++++++++++-----------
 4 files changed, 28 insertions(+), 22 deletions(-)

diff --git a/tests/ui/print_literal.rs b/tests/ui/print_literal.rs
index 0c8aecc2d8c00..8665a3bb28ae1 100644
--- a/tests/ui/print_literal.rs
+++ b/tests/ui/print_literal.rs
@@ -17,6 +17,9 @@ fn main() {
     println!("{bar:8} {foo:>8}", foo = "hello", bar = "world");
     println!("{number:>width$}", number = 1, width = 6);
     println!("{number:>0width$}", number = 1, width = 6);
+    println!("{} of {:b} people know binary, the other half doesn't", 1, 2);
+    println!("10 / 4 is {}", 2.5);
+    println!("2 + 1 = {}", 3);
 
     // these should throw warnings
     print!("Hello {}", "world");
diff --git a/tests/ui/print_literal.stderr b/tests/ui/print_literal.stderr
index 692abdb305443..e284aece236fa 100644
--- a/tests/ui/print_literal.stderr
+++ b/tests/ui/print_literal.stderr
@@ -1,5 +1,5 @@
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:22:24
+  --> $DIR/print_literal.rs:25:24
    |
 LL |     print!("Hello {}", "world");
    |                        ^^^^^^^
@@ -7,61 +7,61 @@ LL |     print!("Hello {}", "world");
    = note: `-D clippy::print-literal` implied by `-D warnings`
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:23:36
+  --> $DIR/print_literal.rs:26:36
    |
 LL |     println!("Hello {} {}", world, "world");
    |                                    ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:24:26
+  --> $DIR/print_literal.rs:27:26
    |
 LL |     println!("Hello {}", "world");
    |                          ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:29:25
+  --> $DIR/print_literal.rs:32:25
    |
 LL |     println!("{0} {1}", "hello", "world");
    |                         ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:29:34
+  --> $DIR/print_literal.rs:32:34
    |
 LL |     println!("{0} {1}", "hello", "world");
    |                                  ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:30:25
+  --> $DIR/print_literal.rs:33:25
    |
 LL |     println!("{1} {0}", "hello", "world");
    |                         ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:30:34
+  --> $DIR/print_literal.rs:33:34
    |
 LL |     println!("{1} {0}", "hello", "world");
    |                                  ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:33:35
+  --> $DIR/print_literal.rs:36:35
    |
 LL |     println!("{foo} {bar}", foo = "hello", bar = "world");
    |                                   ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:33:50
+  --> $DIR/print_literal.rs:36:50
    |
 LL |     println!("{foo} {bar}", foo = "hello", bar = "world");
    |                                                  ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:34:35
+  --> $DIR/print_literal.rs:37:35
    |
 LL |     println!("{bar} {foo}", foo = "hello", bar = "world");
    |                                   ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:34:50
+  --> $DIR/print_literal.rs:37:50
    |
 LL |     println!("{bar} {foo}", foo = "hello", bar = "world");
    |                                                  ^^^^^^^
diff --git a/tests/ui/write_literal.rs b/tests/ui/write_literal.rs
index f5de7ea71d385..0a127858defdf 100644
--- a/tests/ui/write_literal.rs
+++ b/tests/ui/write_literal.rs
@@ -22,6 +22,9 @@ fn main() {
     writeln!(&mut v, "{bar:8} {foo:>8}", foo = "hello", bar = "world");
     writeln!(&mut v, "{number:>width$}", number = 1, width = 6);
     writeln!(&mut v, "{number:>0width$}", number = 1, width = 6);
+    writeln!(&mut v, "{} of {:b} people know binary, the other half doesn't", 1, 2);
+    writeln!(&mut v, "10 / 4 is {}", 2.5);
+    writeln!(&mut v, "2 + 1 = {}", 3);
 
     // these should throw warnings
     write!(&mut v, "Hello {}", "world");
diff --git a/tests/ui/write_literal.stderr b/tests/ui/write_literal.stderr
index 4dcaaa474a88b..e54d89ecf29e6 100644
--- a/tests/ui/write_literal.stderr
+++ b/tests/ui/write_literal.stderr
@@ -1,5 +1,5 @@
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:27:32
+  --> $DIR/write_literal.rs:30:32
    |
 LL |     write!(&mut v, "Hello {}", "world");
    |                                ^^^^^^^
@@ -7,61 +7,61 @@ LL |     write!(&mut v, "Hello {}", "world");
    = note: `-D clippy::write-literal` implied by `-D warnings`
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:28:44
+  --> $DIR/write_literal.rs:31:44
    |
 LL |     writeln!(&mut v, "Hello {} {}", world, "world");
    |                                            ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:29:34
+  --> $DIR/write_literal.rs:32:34
    |
 LL |     writeln!(&mut v, "Hello {}", "world");
    |                                  ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:34:33
+  --> $DIR/write_literal.rs:37:33
    |
 LL |     writeln!(&mut v, "{0} {1}", "hello", "world");
    |                                 ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:34:42
+  --> $DIR/write_literal.rs:37:42
    |
 LL |     writeln!(&mut v, "{0} {1}", "hello", "world");
    |                                          ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:35:33
+  --> $DIR/write_literal.rs:38:33
    |
 LL |     writeln!(&mut v, "{1} {0}", "hello", "world");
    |                                 ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:35:42
+  --> $DIR/write_literal.rs:38:42
    |
 LL |     writeln!(&mut v, "{1} {0}", "hello", "world");
    |                                          ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:38:43
+  --> $DIR/write_literal.rs:41:43
    |
 LL |     writeln!(&mut v, "{foo} {bar}", foo = "hello", bar = "world");
    |                                           ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:38:58
+  --> $DIR/write_literal.rs:41:58
    |
 LL |     writeln!(&mut v, "{foo} {bar}", foo = "hello", bar = "world");
    |                                                          ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:39:43
+  --> $DIR/write_literal.rs:42:43
    |
 LL |     writeln!(&mut v, "{bar} {foo}", foo = "hello", bar = "world");
    |                                           ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:39:58
+  --> $DIR/write_literal.rs:42:58
    |
 LL |     writeln!(&mut v, "{bar} {foo}", foo = "hello", bar = "world");
    |                                                          ^^^^^^^

From abb40c965f4986a346b157dba65d20da4a722813 Mon Sep 17 00:00:00 2001
From: Joshua Nelson <jyn514@gmail.com>
Date: Sun, 17 Jan 2021 14:23:25 -0500
Subject: [PATCH 037/108] Fix formatting for removed lints

- Don't add backticks for the reason a lint was removed. This is almost
never a code block, and when it is the backticks should be in the reason
itself.
- Don't assume clippy is the only tool that needs to be checked for
backwards compatibility
---
 tests/ui/deprecated.stderr     | 26 +++++++++++++-------------
 tests/ui/deprecated_old.stderr |  8 ++++----
 2 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/tests/ui/deprecated.stderr b/tests/ui/deprecated.stderr
index 3429317498ed6..f361db6b147da 100644
--- a/tests/ui/deprecated.stderr
+++ b/tests/ui/deprecated.stderr
@@ -1,4 +1,4 @@
-error: lint `clippy::unstable_as_slice` has been removed: ``Vec::as_slice` has been stabilized in 1.7`
+error: lint `clippy::unstable_as_slice` has been removed: `Vec::as_slice` has been stabilized in 1.7
   --> $DIR/deprecated.rs:1:8
    |
 LL | #[warn(clippy::unstable_as_slice)]
@@ -6,73 +6,73 @@ LL | #[warn(clippy::unstable_as_slice)]
    |
    = note: `-D renamed-and-removed-lints` implied by `-D warnings`
 
-error: lint `clippy::unstable_as_mut_slice` has been removed: ``Vec::as_mut_slice` has been stabilized in 1.7`
+error: lint `clippy::unstable_as_mut_slice` has been removed: `Vec::as_mut_slice` has been stabilized in 1.7
   --> $DIR/deprecated.rs:2:8
    |
 LL | #[warn(clippy::unstable_as_mut_slice)]
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::misaligned_transmute` has been removed: `this lint has been split into cast_ptr_alignment and transmute_ptr_to_ptr`
+error: lint `clippy::misaligned_transmute` has been removed: this lint has been split into cast_ptr_alignment and transmute_ptr_to_ptr
   --> $DIR/deprecated.rs:3:8
    |
 LL | #[warn(clippy::misaligned_transmute)]
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::unused_collect` has been removed: ``collect` has been marked as #[must_use] in rustc and that covers all cases of this lint`
+error: lint `clippy::unused_collect` has been removed: `collect` has been marked as #[must_use] in rustc and that covers all cases of this lint
   --> $DIR/deprecated.rs:4:8
    |
 LL | #[warn(clippy::unused_collect)]
    |        ^^^^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::invalid_ref` has been removed: `superseded by rustc lint `invalid_value``
+error: lint `clippy::invalid_ref` has been removed: superseded by rustc lint `invalid_value`
   --> $DIR/deprecated.rs:5:8
    |
 LL | #[warn(clippy::invalid_ref)]
    |        ^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::into_iter_on_array` has been removed: `this lint has been uplifted to rustc and is now called `array_into_iter``
+error: lint `clippy::into_iter_on_array` has been removed: this lint has been uplifted to rustc and is now called `array_into_iter`
   --> $DIR/deprecated.rs:6:8
    |
 LL | #[warn(clippy::into_iter_on_array)]
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::unused_label` has been removed: `this lint has been uplifted to rustc and is now called `unused_labels``
+error: lint `clippy::unused_label` has been removed: this lint has been uplifted to rustc and is now called `unused_labels`
   --> $DIR/deprecated.rs:7:8
    |
 LL | #[warn(clippy::unused_label)]
    |        ^^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::regex_macro` has been removed: `the regex! macro has been removed from the regex crate in 2018`
+error: lint `clippy::regex_macro` has been removed: the regex! macro has been removed from the regex crate in 2018
   --> $DIR/deprecated.rs:8:8
    |
 LL | #[warn(clippy::regex_macro)]
    |        ^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::drop_bounds` has been removed: `this lint has been uplifted to rustc and is now called `drop_bounds``
+error: lint `clippy::drop_bounds` has been removed: this lint has been uplifted to rustc and is now called `drop_bounds`
   --> $DIR/deprecated.rs:9:8
    |
 LL | #[warn(clippy::drop_bounds)]
    |        ^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::temporary_cstring_as_ptr` has been removed: `this lint has been uplifted to rustc and is now called `temporary_cstring_as_ptr``
+error: lint `clippy::temporary_cstring_as_ptr` has been removed: this lint has been uplifted to rustc and is now called `temporary_cstring_as_ptr`
   --> $DIR/deprecated.rs:10:8
    |
 LL | #[warn(clippy::temporary_cstring_as_ptr)]
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::panic_params` has been removed: `this lint has been uplifted to rustc and is now called `panic_fmt``
+error: lint `clippy::panic_params` has been removed: this lint has been uplifted to rustc and is now called `panic_fmt`
   --> $DIR/deprecated.rs:11:8
    |
 LL | #[warn(clippy::panic_params)]
    |        ^^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::unknown_clippy_lints` has been removed: `this lint has been integrated into the `unknown_lints` rustc lint`
+error: lint `clippy::unknown_clippy_lints` has been removed: this lint has been integrated into the `unknown_lints` rustc lint
   --> $DIR/deprecated.rs:12:8
    |
 LL | #[warn(clippy::unknown_clippy_lints)]
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::unstable_as_slice` has been removed: ``Vec::as_slice` has been stabilized in 1.7`
+error: lint `clippy::unstable_as_slice` has been removed: `Vec::as_slice` has been stabilized in 1.7
   --> $DIR/deprecated.rs:1:8
    |
 LL | #[warn(clippy::unstable_as_slice)]
diff --git a/tests/ui/deprecated_old.stderr b/tests/ui/deprecated_old.stderr
index 2fe1facf0c72d..b8550078c4600 100644
--- a/tests/ui/deprecated_old.stderr
+++ b/tests/ui/deprecated_old.stderr
@@ -1,4 +1,4 @@
-error: lint `unstable_as_slice` has been removed: ``Vec::as_slice` has been stabilized in 1.7`
+error: lint `unstable_as_slice` has been removed: `Vec::as_slice` has been stabilized in 1.7
   --> $DIR/deprecated_old.rs:1:8
    |
 LL | #[warn(unstable_as_slice)]
@@ -6,19 +6,19 @@ LL | #[warn(unstable_as_slice)]
    |
    = note: `-D renamed-and-removed-lints` implied by `-D warnings`
 
-error: lint `unstable_as_mut_slice` has been removed: ``Vec::as_mut_slice` has been stabilized in 1.7`
+error: lint `unstable_as_mut_slice` has been removed: `Vec::as_mut_slice` has been stabilized in 1.7
   --> $DIR/deprecated_old.rs:2:8
    |
 LL | #[warn(unstable_as_mut_slice)]
    |        ^^^^^^^^^^^^^^^^^^^^^
 
-error: lint `misaligned_transmute` has been removed: `this lint has been split into cast_ptr_alignment and transmute_ptr_to_ptr`
+error: lint `misaligned_transmute` has been removed: this lint has been split into cast_ptr_alignment and transmute_ptr_to_ptr
   --> $DIR/deprecated_old.rs:3:8
    |
 LL | #[warn(misaligned_transmute)]
    |        ^^^^^^^^^^^^^^^^^^^^
 
-error: lint `unstable_as_slice` has been removed: ``Vec::as_slice` has been stabilized in 1.7`
+error: lint `unstable_as_slice` has been removed: `Vec::as_slice` has been stabilized in 1.7
   --> $DIR/deprecated_old.rs:1:8
    |
 LL | #[warn(unstable_as_slice)]

From c3244c25ac5ccc2923105dfb903d6d4237ed1872 Mon Sep 17 00:00:00 2001
From: "kai.giebeler" <kai.giebeler@audiotool.com>
Date: Sun, 17 Jan 2021 22:57:08 +0100
Subject: [PATCH 038/108] add test for doc_valid_idents "WebGL"

---
 tests/ui/doc.rs     |  1 +
 tests/ui/doc.stderr | 44 ++++++++++++++++++++++----------------------
 2 files changed, 23 insertions(+), 22 deletions(-)

diff --git a/tests/ui/doc.rs b/tests/ui/doc.rs
index 68c5d32846f19..e30970ed95273 100644
--- a/tests/ui/doc.rs
+++ b/tests/ui/doc.rs
@@ -53,6 +53,7 @@ fn test_units() {
 /// DirectX
 /// ECMAScript
 /// OAuth GraphQL
+/// WebGL
 /// TeX LaTeX BibTeX BibLaTeX
 /// CamelCase (see also #2395)
 /// be_sure_we_got_to_the_end_of_it
diff --git a/tests/ui/doc.stderr b/tests/ui/doc.stderr
index 23fca43590b4f..e1c1aa85a60e1 100644
--- a/tests/ui/doc.stderr
+++ b/tests/ui/doc.stderr
@@ -55,133 +55,133 @@ LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:58:5
+  --> $DIR/doc.rs:59:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: you should put `link_with_underscores` between ticks in the documentation
-  --> $DIR/doc.rs:62:22
+  --> $DIR/doc.rs:63:22
    |
 LL | /// This test has [a link_with_underscores][chunked-example] inside it. See #823.
    |                      ^^^^^^^^^^^^^^^^^^^^^
 
 error: you should put `inline_link2` between ticks in the documentation
-  --> $DIR/doc.rs:65:21
+  --> $DIR/doc.rs:66:21
    |
 LL | /// It can also be [inline_link2].
    |                     ^^^^^^^^^^^^
 
 error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:75:5
+  --> $DIR/doc.rs:76:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: you should put `CamelCaseThing` between ticks in the documentation
-  --> $DIR/doc.rs:83:8
+  --> $DIR/doc.rs:84:8
    |
 LL | /// ## CamelCaseThing
    |        ^^^^^^^^^^^^^^
 
 error: you should put `CamelCaseThing` between ticks in the documentation
-  --> $DIR/doc.rs:86:7
+  --> $DIR/doc.rs:87:7
    |
 LL | /// # CamelCaseThing
    |       ^^^^^^^^^^^^^^
 
 error: you should put `CamelCaseThing` between ticks in the documentation
-  --> $DIR/doc.rs:88:22
+  --> $DIR/doc.rs:89:22
    |
 LL | /// Not a title #897 CamelCaseThing
    |                      ^^^^^^^^^^^^^^
 
 error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:89:5
+  --> $DIR/doc.rs:90:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:96:5
+  --> $DIR/doc.rs:97:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:109:5
+  --> $DIR/doc.rs:110:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: you should put `FooBar` between ticks in the documentation
-  --> $DIR/doc.rs:120:43
+  --> $DIR/doc.rs:121:43
    |
 LL | /** E.g., serialization of an empty list: FooBar
    |                                           ^^^^^^
 
 error: you should put `BarQuz` between ticks in the documentation
-  --> $DIR/doc.rs:125:5
+  --> $DIR/doc.rs:126:5
    |
 LL | And BarQuz too.
    |     ^^^^^^
 
 error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:126:1
+  --> $DIR/doc.rs:127:1
    |
 LL | be_sure_we_got_to_the_end_of_it
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: you should put `FooBar` between ticks in the documentation
-  --> $DIR/doc.rs:131:43
+  --> $DIR/doc.rs:132:43
    |
 LL | /** E.g., serialization of an empty list: FooBar
    |                                           ^^^^^^
 
 error: you should put `BarQuz` between ticks in the documentation
-  --> $DIR/doc.rs:136:5
+  --> $DIR/doc.rs:137:5
    |
 LL | And BarQuz too.
    |     ^^^^^^
 
 error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:137:1
+  --> $DIR/doc.rs:138:1
    |
 LL | be_sure_we_got_to_the_end_of_it
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:148:5
+  --> $DIR/doc.rs:149:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: you should put bare URLs between `<`/`>` or make a proper Markdown link
-  --> $DIR/doc.rs:175:13
+  --> $DIR/doc.rs:176:13
    |
 LL | /// Not ok: http://www.unicode.org
    |             ^^^^^^^^^^^^^^^^^^^^^^
 
 error: you should put bare URLs between `<`/`>` or make a proper Markdown link
-  --> $DIR/doc.rs:176:13
+  --> $DIR/doc.rs:177:13
    |
 LL | /// Not ok: https://www.unicode.org
    |             ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: you should put bare URLs between `<`/`>` or make a proper Markdown link
-  --> $DIR/doc.rs:177:13
+  --> $DIR/doc.rs:178:13
    |
 LL | /// Not ok: http://www.unicode.org/
    |             ^^^^^^^^^^^^^^^^^^^^^^
 
 error: you should put bare URLs between `<`/`>` or make a proper Markdown link
-  --> $DIR/doc.rs:178:13
+  --> $DIR/doc.rs:179:13
    |
 LL | /// Not ok: http://www.unicode.org/reports/tr9/#Reordering_Resolved_Levels
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: you should put `mycrate::Collection` between ticks in the documentation
-  --> $DIR/doc.rs:181:22
+  --> $DIR/doc.rs:182:22
    |
 LL | /// An iterator over mycrate::Collection's values.
    |                      ^^^^^^^^^^^^^^^^^^^

From dce2262daea813f67fb8cce4e76eb5909ef510cb Mon Sep 17 00:00:00 2001
From: LeSeulArtichaut <leseulartichaut@gmail.com>
Date: Sat, 12 Dec 2020 15:32:45 +0100
Subject: [PATCH 039/108] Use ty::{IntTy,UintTy,FloatTy} in rustdoc and clippy

---
 clippy_lints/src/bytecount.rs     |  3 +--
 clippy_lints/src/consts.rs        |  8 ++++----
 clippy_lints/src/enum_clike.rs    |  3 +--
 clippy_lints/src/float_literal.rs |  8 ++++----
 clippy_lints/src/mutex_atomic.rs  |  5 ++---
 clippy_lints/src/transmute.rs     |  6 +++---
 clippy_lints/src/types.rs         |  8 +++-----
 clippy_lints/src/utils/mod.rs     | 13 ++++++-------
 8 files changed, 24 insertions(+), 30 deletions(-)

diff --git a/clippy_lints/src/bytecount.rs b/clippy_lints/src/bytecount.rs
index 38a0e27c4cf5b..ac9098a7584d6 100644
--- a/clippy_lints/src/bytecount.rs
+++ b/clippy_lints/src/bytecount.rs
@@ -2,11 +2,10 @@ use crate::utils::{
     contains_name, get_pat_name, match_type, paths, single_segment_path, snippet_with_applicability, span_lint_and_sugg,
 };
 use if_chain::if_chain;
-use rustc_ast::ast::UintTy;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty;
+use rustc_middle::ty::{self, UintTy};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 use rustc_span::Symbol;
diff --git a/clippy_lints/src/consts.rs b/clippy_lints/src/consts.rs
index 166eadf86c177..640cffd24a701 100644
--- a/clippy_lints/src/consts.rs
+++ b/clippy_lints/src/consts.rs
@@ -2,14 +2,14 @@
 
 use crate::utils::{clip, sext, unsext};
 use if_chain::if_chain;
-use rustc_ast::ast::{FloatTy, LitFloatType, LitKind};
+use rustc_ast::ast::{self, LitFloatType, LitKind};
 use rustc_data_structures::sync::Lrc;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{BinOp, BinOpKind, Block, Expr, ExprKind, HirId, QPath, UnOp};
 use rustc_lint::LateContext;
 use rustc_middle::mir::interpret::Scalar;
 use rustc_middle::ty::subst::{Subst, SubstsRef};
-use rustc_middle::ty::{self, ScalarInt, Ty, TyCtxt};
+use rustc_middle::ty::{self, FloatTy, ScalarInt, Ty, TyCtxt};
 use rustc_middle::{bug, span_bug};
 use rustc_span::symbol::Symbol;
 use std::cmp::Ordering::{self, Equal};
@@ -167,8 +167,8 @@ pub fn lit_to_constant(lit: &LitKind, ty: Option<Ty<'_>>) -> Constant {
         LitKind::Char(c) => Constant::Char(c),
         LitKind::Int(n, _) => Constant::Int(n),
         LitKind::Float(ref is, LitFloatType::Suffixed(fty)) => match fty {
-            FloatTy::F32 => Constant::F32(is.as_str().parse().unwrap()),
-            FloatTy::F64 => Constant::F64(is.as_str().parse().unwrap()),
+            ast::FloatTy::F32 => Constant::F32(is.as_str().parse().unwrap()),
+            ast::FloatTy::F64 => Constant::F64(is.as_str().parse().unwrap()),
         },
         LitKind::Float(ref is, LitFloatType::Unsuffixed) => match ty.expect("type of float is known").kind() {
             ty::Float(FloatTy::F32) => Constant::F32(is.as_str().parse().unwrap()),
diff --git a/clippy_lints/src/enum_clike.rs b/clippy_lints/src/enum_clike.rs
index fb80f48a9ccf3..ae56a8ba5ab4b 100644
--- a/clippy_lints/src/enum_clike.rs
+++ b/clippy_lints/src/enum_clike.rs
@@ -3,10 +3,9 @@
 
 use crate::consts::{miri_to_const, Constant};
 use crate::utils::span_lint;
-use rustc_ast::ast::{IntTy, UintTy};
 use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty;
+use rustc_middle::ty::{self, IntTy, UintTy};
 use rustc_middle::ty::util::IntTypeExt;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use std::convert::TryFrom;
diff --git a/clippy_lints/src/float_literal.rs b/clippy_lints/src/float_literal.rs
index 1fe4461533b36..be646cbe4d043 100644
--- a/clippy_lints/src/float_literal.rs
+++ b/clippy_lints/src/float_literal.rs
@@ -1,10 +1,10 @@
 use crate::utils::{numeric_literal, span_lint_and_sugg};
 use if_chain::if_chain;
-use rustc_ast::ast::{FloatTy, LitFloatType, LitKind};
+use rustc_ast::ast::{self, LitFloatType, LitKind};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty;
+use rustc_middle::ty::{self, FloatTy};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use std::fmt;
 
@@ -75,8 +75,8 @@ impl<'tcx> LateLintPass<'tcx> for FloatLiteral {
                 let digits = count_digits(&sym_str);
                 let max = max_digits(fty);
                 let type_suffix = match lit_float_ty {
-                    LitFloatType::Suffixed(FloatTy::F32) => Some("f32"),
-                    LitFloatType::Suffixed(FloatTy::F64) => Some("f64"),
+                    LitFloatType::Suffixed(ast::FloatTy::F32) => Some("f32"),
+                    LitFloatType::Suffixed(ast::FloatTy::F64) => Some("f64"),
                     LitFloatType::Unsuffixed => None
                 };
                 let (is_whole, mut float_str) = match fty {
diff --git a/clippy_lints/src/mutex_atomic.rs b/clippy_lints/src/mutex_atomic.rs
index ea986874291e0..40b236493a313 100644
--- a/clippy_lints/src/mutex_atomic.rs
+++ b/clippy_lints/src/mutex_atomic.rs
@@ -3,7 +3,6 @@
 //! This lint is **warn** by default
 
 use crate::utils::{is_type_diagnostic_item, span_lint};
-use rustc_ast::ast;
 use rustc_hir::Expr;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, Ty};
@@ -77,8 +76,8 @@ impl<'tcx> LateLintPass<'tcx> for Mutex {
                         atomic_name
                     );
                     match *mutex_param.kind() {
-                        ty::Uint(t) if t != ast::UintTy::Usize => span_lint(cx, MUTEX_INTEGER, expr.span, &msg),
-                        ty::Int(t) if t != ast::IntTy::Isize => span_lint(cx, MUTEX_INTEGER, expr.span, &msg),
+                        ty::Uint(t) if t != ty::UintTy::Usize => span_lint(cx, MUTEX_INTEGER, expr.span, &msg),
+                        ty::Int(t) if t != ty::IntTy::Isize => span_lint(cx, MUTEX_INTEGER, expr.span, &msg),
                         _ => span_lint(cx, MUTEX_ATOMIC, expr.span, &msg),
                     };
                 }
diff --git a/clippy_lints/src/transmute.rs b/clippy_lints/src/transmute.rs
index b0909f7317740..d977cea4da50b 100644
--- a/clippy_lints/src/transmute.rs
+++ b/clippy_lints/src/transmute.rs
@@ -443,7 +443,7 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                             );
                         },
                     ),
-                    (ty::Int(ast::IntTy::I32) | ty::Uint(ast::UintTy::U32), &ty::Char) => {
+                    (ty::Int(ty::IntTy::I32) | ty::Uint(ty::UintTy::U32), &ty::Char) => {
                         span_lint_and_then(
                             cx,
                             TRANSMUTE_INT_TO_CHAR,
@@ -468,7 +468,7 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                     (ty::Ref(_, ty_from, from_mutbl), ty::Ref(_, ty_to, to_mutbl)) => {
                         if_chain! {
                             if let (&ty::Slice(slice_ty), &ty::Str) = (&ty_from.kind(), &ty_to.kind());
-                            if let ty::Uint(ast::UintTy::U8) = slice_ty.kind();
+                            if let ty::Uint(ty::UintTy::U8) = slice_ty.kind();
                             if from_mutbl == to_mutbl;
                             then {
                                 let postfix = if *from_mutbl == Mutability::Mut {
@@ -536,7 +536,7 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                             }
                         },
                     ),
-                    (ty::Int(ast::IntTy::I8) | ty::Uint(ast::UintTy::U8), ty::Bool) => {
+                    (ty::Int(ty::IntTy::I8) | ty::Uint(ty::UintTy::U8), ty::Bool) => {
                         span_lint_and_then(
                             cx,
                             TRANSMUTE_INT_TO_BOOL,
diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 3b5a83d2a0bec..17cef0af3e9c9 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -5,7 +5,7 @@ use std::cmp::Ordering;
 use std::collections::BTreeMap;
 
 use if_chain::if_chain;
-use rustc_ast::{FloatTy, IntTy, LitFloatType, LitIntType, LitKind, UintTy};
+use rustc_ast::{LitFloatType, LitIntType, LitKind};
 use rustc_errors::{Applicability, DiagnosticBuilder};
 use rustc_hir as hir;
 use rustc_hir::intravisit::{walk_body, walk_expr, walk_ty, FnKind, NestedVisitorMap, Visitor};
@@ -18,7 +18,7 @@ use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::TypeFoldable;
-use rustc_middle::ty::{self, InferTy, Ty, TyCtxt, TyS, TypeAndMut, TypeckResults};
+use rustc_middle::ty::{self, FloatTy, InferTy, IntTy, Ty, TyCtxt, TyS, TypeAndMut, TypeckResults, UintTy};
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
 use rustc_span::hygiene::{ExpnKind, MacroKind};
@@ -1106,9 +1106,7 @@ fn is_empty_block(expr: &Expr<'_>) -> bool {
         expr.kind,
         ExprKind::Block(
             Block {
-                stmts: &[],
-                expr: None,
-                ..
+                stmts: &[], expr: None, ..
             },
             _,
         )
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 9b262517a9834..46b2b06d1a280 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -35,7 +35,6 @@ use std::mem;
 
 use if_chain::if_chain;
 use rustc_ast::ast::{self, Attribute, LitKind};
-use rustc_attr as attr;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -1224,27 +1223,27 @@ pub fn get_arg_name(pat: &Pat<'_>) -> Option<Symbol> {
     }
 }
 
-pub fn int_bits(tcx: TyCtxt<'_>, ity: ast::IntTy) -> u64 {
-    Integer::from_attr(&tcx, attr::IntType::SignedInt(ity)).size().bits()
+pub fn int_bits(tcx: TyCtxt<'_>, ity: ty::IntTy) -> u64 {
+    Integer::from_int_ty(&tcx, ity).size().bits()
 }
 
 #[allow(clippy::cast_possible_wrap)]
 /// Turn a constant int byte representation into an i128
-pub fn sext(tcx: TyCtxt<'_>, u: u128, ity: ast::IntTy) -> i128 {
+pub fn sext(tcx: TyCtxt<'_>, u: u128, ity: ty::IntTy) -> i128 {
     let amt = 128 - int_bits(tcx, ity);
     ((u as i128) << amt) >> amt
 }
 
 #[allow(clippy::cast_sign_loss)]
 /// clip unused bytes
-pub fn unsext(tcx: TyCtxt<'_>, u: i128, ity: ast::IntTy) -> u128 {
+pub fn unsext(tcx: TyCtxt<'_>, u: i128, ity: ty::IntTy) -> u128 {
     let amt = 128 - int_bits(tcx, ity);
     ((u as u128) << amt) >> amt
 }
 
 /// clip unused bytes
-pub fn clip(tcx: TyCtxt<'_>, u: u128, ity: ast::UintTy) -> u128 {
-    let bits = Integer::from_attr(&tcx, attr::IntType::UnsignedInt(ity)).size().bits();
+pub fn clip(tcx: TyCtxt<'_>, u: u128, ity: ty::UintTy) -> u128 {
+    let bits = Integer::from_uint_ty(&tcx, ity).size().bits();
     let amt = 128 - bits;
     (u << amt) >> amt
 }

From 2454408318814a2451b0698fa6d1cbffcaafda5f Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 18 Jan 2021 13:36:32 -0600
Subject: [PATCH 040/108] Remove qpath_res util function

---
 clippy_lints/src/default.rs              |  4 ++--
 clippy_lints/src/drop_forget_ref.rs      |  4 ++--
 clippy_lints/src/exit.rs                 |  4 ++--
 clippy_lints/src/functions.rs            |  8 ++++----
 clippy_lints/src/let_if_seq.rs           |  4 ++--
 clippy_lints/src/loops.rs                | 22 +++++++++++-----------
 clippy_lints/src/manual_strip.rs         |  8 ++++----
 clippy_lints/src/mem_forget.rs           |  4 ++--
 clippy_lints/src/no_effect.rs            |  6 +++---
 clippy_lints/src/non_copy_const.rs       |  4 ++--
 clippy_lints/src/to_string_in_display.rs |  4 ++--
 clippy_lints/src/types.rs                | 12 ++++++------
 clippy_lints/src/utils/internal_lints.rs |  6 +++---
 clippy_lints/src/utils/mod.rs            | 13 -------------
 14 files changed, 45 insertions(+), 58 deletions(-)

diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index f7224811e6e79..6fa1378b8c73d 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -1,5 +1,5 @@
 use crate::utils::{
-    any_parent_is_automatically_derived, contains_name, match_def_path, paths, qpath_res, snippet_with_macro_callsite,
+    any_parent_is_automatically_derived, contains_name, match_def_path, paths, snippet_with_macro_callsite,
 };
 use crate::utils::{span_lint_and_note, span_lint_and_sugg};
 use if_chain::if_chain;
@@ -231,7 +231,7 @@ fn is_expr_default<'tcx>(expr: &'tcx Expr<'tcx>, cx: &LateContext<'tcx>) -> bool
     if_chain! {
         if let ExprKind::Call(ref fn_expr, _) = &expr.kind;
         if let ExprKind::Path(qpath) = &fn_expr.kind;
-        if let Res::Def(_, def_id) = qpath_res(cx, qpath, fn_expr.hir_id);
+        if let Res::Def(_, def_id) = cx.qpath_res(qpath, fn_expr.hir_id);
         then {
             // right hand side of assignment is `Default::default`
             match_def_path(cx, def_id, &paths::DEFAULT_TRAIT_METHOD)
diff --git a/clippy_lints/src/drop_forget_ref.rs b/clippy_lints/src/drop_forget_ref.rs
index cf528d189b4b1..a84f9c4628716 100644
--- a/clippy_lints/src/drop_forget_ref.rs
+++ b/clippy_lints/src/drop_forget_ref.rs
@@ -1,4 +1,4 @@
-use crate::utils::{is_copy, match_def_path, paths, qpath_res, span_lint_and_note};
+use crate::utils::{is_copy, match_def_path, paths, span_lint_and_note};
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -114,7 +114,7 @@ impl<'tcx> LateLintPass<'tcx> for DropForgetRef {
             if let ExprKind::Call(ref path, ref args) = expr.kind;
             if let ExprKind::Path(ref qpath) = path.kind;
             if args.len() == 1;
-            if let Some(def_id) = qpath_res(cx, qpath, path.hir_id).opt_def_id();
+            if let Some(def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id();
             then {
                 let lint;
                 let msg;
diff --git a/clippy_lints/src/exit.rs b/clippy_lints/src/exit.rs
index 7337d98c8be37..915859270009b 100644
--- a/clippy_lints/src/exit.rs
+++ b/clippy_lints/src/exit.rs
@@ -1,4 +1,4 @@
-use crate::utils::{is_entrypoint_fn, match_def_path, paths, qpath_res, span_lint};
+use crate::utils::{is_entrypoint_fn, match_def_path, paths, span_lint};
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind, Item, ItemKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
@@ -29,7 +29,7 @@ impl<'tcx> LateLintPass<'tcx> for Exit {
         if_chain! {
             if let ExprKind::Call(ref path_expr, ref _args) = e.kind;
             if let ExprKind::Path(ref path) = path_expr.kind;
-            if let Some(def_id) = qpath_res(cx, path, path_expr.hir_id).opt_def_id();
+            if let Some(def_id) = cx.qpath_res(path, path_expr.hir_id).opt_def_id();
             if match_def_path(cx, def_id, &paths::EXIT);
             then {
                 let parent = cx.tcx.hir().get_parent_item(e.hir_id);
diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs
index fd93548b55c6d..8795425461033 100644
--- a/clippy_lints/src/functions.rs
+++ b/clippy_lints/src/functions.rs
@@ -1,7 +1,7 @@
 use crate::utils::{
     attr_by_name, attrs::is_proc_macro, is_must_use_ty, is_trait_impl_item, is_type_diagnostic_item, iter_input_pats,
-    last_path_segment, match_def_path, must_use_attr, qpath_res, return_ty, snippet, snippet_opt, span_lint,
-    span_lint_and_help, span_lint_and_then, trait_ref_of_method, type_is_unsafe_function,
+    last_path_segment, match_def_path, must_use_attr, return_ty, snippet, snippet_opt, span_lint, span_lint_and_help,
+    span_lint_and_then, trait_ref_of_method, type_is_unsafe_function,
 };
 use if_chain::if_chain;
 use rustc_ast::ast::Attribute;
@@ -659,7 +659,7 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for DerefVisitor<'a, 'tcx> {
 impl<'a, 'tcx> DerefVisitor<'a, 'tcx> {
     fn check_arg(&self, ptr: &hir::Expr<'_>) {
         if let hir::ExprKind::Path(ref qpath) = ptr.kind {
-            if let Res::Local(id) = qpath_res(self.cx, qpath, ptr.hir_id) {
+            if let Res::Local(id) = self.cx.qpath_res(qpath, ptr.hir_id) {
                 if self.ptrs.contains(&id) {
                     span_lint(
                         self.cx,
@@ -722,7 +722,7 @@ fn is_mutated_static(cx: &LateContext<'_>, e: &hir::Expr<'_>) -> bool {
     use hir::ExprKind::{Field, Index, Path};
 
     match e.kind {
-        Path(ref qpath) => !matches!(qpath_res(cx, qpath, e.hir_id), Res::Local(_)),
+        Path(ref qpath) => !matches!(cx.qpath_res(qpath, e.hir_id), Res::Local(_)),
         Field(ref inner, _) | Index(ref inner, _) => is_mutated_static(cx, inner),
         _ => false,
     }
diff --git a/clippy_lints/src/let_if_seq.rs b/clippy_lints/src/let_if_seq.rs
index db717cd1240a4..5886c2360e362 100644
--- a/clippy_lints/src/let_if_seq.rs
+++ b/clippy_lints/src/let_if_seq.rs
@@ -1,4 +1,4 @@
-use crate::utils::{qpath_res, snippet, span_lint_and_then, visitors::LocalUsedVisitor};
+use crate::utils::{snippet, span_lint_and_then, visitors::LocalUsedVisitor};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -145,7 +145,7 @@ fn check_assign<'tcx>(
         if let hir::StmtKind::Semi(ref expr) = expr.kind;
         if let hir::ExprKind::Assign(ref var, ref value, _) = expr.kind;
         if let hir::ExprKind::Path(ref qpath) = var.kind;
-        if let Res::Local(local_id) = qpath_res(cx, qpath, var.hir_id);
+        if let Res::Local(local_id) = cx.qpath_res(qpath, var.hir_id);
         if decl == local_id;
         then {
             let mut v = LocalUsedVisitor::new(decl);
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 1c5ab2874b048..1ae2c6ca95788 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -6,9 +6,9 @@ use crate::utils::visitors::LocalUsedVisitor;
 use crate::utils::{
     contains_name, get_enclosing_block, get_parent_expr, get_trait_def_id, has_iter_method, higher, implements_trait,
     indent_of, is_in_panic_handler, is_integer_const, is_no_std_crate, is_refutable, is_type_diagnostic_item,
-    last_path_segment, match_trait_method, match_type, match_var, multispan_sugg, qpath_res, single_segment_path,
-    snippet, snippet_with_applicability, snippet_with_macro_callsite, span_lint, span_lint_and_help,
-    span_lint_and_sugg, span_lint_and_then, sugg, SpanlessEq,
+    last_path_segment, match_trait_method, match_type, match_var, multispan_sugg, single_segment_path, snippet,
+    snippet_with_applicability, snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg,
+    span_lint_and_then, sugg, SpanlessEq,
 };
 use if_chain::if_chain;
 use rustc_ast::ast;
@@ -848,7 +848,7 @@ fn same_var<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, var: HirId) -> bool {
         if let ExprKind::Path(qpath) = &expr.kind;
         if let QPath::Resolved(None, path) = qpath;
         if path.segments.len() == 1;
-        if let Res::Local(local_id) = qpath_res(cx, qpath, expr.hir_id);
+        if let Res::Local(local_id) = cx.qpath_res(qpath, expr.hir_id);
         then {
             // our variable!
             local_id == var
@@ -1420,7 +1420,7 @@ fn detect_same_item_push<'tcx>(
                 // Make sure that the push does not involve possibly mutating values
                 match pushed_item.kind {
                     ExprKind::Path(ref qpath) => {
-                        match qpath_res(cx, qpath, pushed_item.hir_id) {
+                        match cx.qpath_res(qpath, pushed_item.hir_id) {
                             // immutable bindings that are initialized with literal or constant
                             Res::Local(hir_id) => {
                                 if_chain! {
@@ -1437,7 +1437,7 @@ fn detect_same_item_push<'tcx>(
                                             ExprKind::Lit(..) => emit_lint(cx, vec, pushed_item),
                                             // immutable bindings that are initialized with constant
                                             ExprKind::Path(ref path) => {
-                                                if let Res::Def(DefKind::Const, ..) = qpath_res(cx, path, init.hir_id) {
+                                                if let Res::Def(DefKind::Const, ..) = cx.qpath_res(path, init.hir_id) {
                                                     emit_lint(cx, vec, pushed_item);
                                                 }
                                             }
@@ -2028,7 +2028,7 @@ fn check_for_mutability(cx: &LateContext<'_>, bound: &Expr<'_>) -> Option<HirId>
         if let ExprKind::Path(ref qpath) = bound.kind;
         if let QPath::Resolved(None, _) = *qpath;
         then {
-            let res = qpath_res(cx, qpath, bound.hir_id);
+            let res = cx.qpath_res(qpath, bound.hir_id);
             if let Res::Local(hir_id) = res {
                 let node_str = cx.tcx.hir().get(hir_id);
                 if_chain! {
@@ -2120,7 +2120,7 @@ impl<'a, 'tcx> VarVisitor<'a, 'tcx> {
                     if self.prefer_mutable {
                         self.indexed_mut.insert(seqvar.segments[0].ident.name);
                     }
-                    let res = qpath_res(self.cx, seqpath, seqexpr.hir_id);
+                    let res = self.cx.qpath_res(seqpath, seqexpr.hir_id);
                     match res {
                         Res::Local(hir_id) => {
                             let parent_id = self.cx.tcx.hir().get_parent_item(expr.hir_id);
@@ -2184,7 +2184,7 @@ impl<'a, 'tcx> Visitor<'tcx> for VarVisitor<'a, 'tcx> {
             if let QPath::Resolved(None, ref path) = *qpath;
             if path.segments.len() == 1;
             then {
-                if let Res::Local(local_id) = qpath_res(self.cx, qpath, expr.hir_id) {
+                if let Res::Local(local_id) = self.cx.qpath_res(qpath, expr.hir_id) {
                     if local_id == self.var {
                         self.nonindex = true;
                     } else {
@@ -2589,7 +2589,7 @@ impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
 
 fn var_def_id(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<HirId> {
     if let ExprKind::Path(ref qpath) = expr.kind {
-        let path_res = qpath_res(cx, qpath, expr.hir_id);
+        let path_res = cx.qpath_res(qpath, expr.hir_id);
         if let Res::Local(hir_id) = path_res {
             return Some(hir_id);
         }
@@ -2819,7 +2819,7 @@ impl<'a, 'tcx> VarCollectorVisitor<'a, 'tcx> {
         if_chain! {
             if let ExprKind::Path(ref qpath) = ex.kind;
             if let QPath::Resolved(None, _) = *qpath;
-            let res = qpath_res(self.cx, qpath, ex.hir_id);
+            let res = self.cx.qpath_res(qpath, ex.hir_id);
             then {
                 match res {
                     Res::Local(hir_id) => {
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index a0cfe145a301c..42a92104a4919 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -1,7 +1,7 @@
 use crate::consts::{constant, Constant};
 use crate::utils::usage::mutated_variables;
 use crate::utils::{
-    eq_expr_value, higher, match_def_path, meets_msrv, multispan_sugg, paths, qpath_res, snippet, span_lint_and_then,
+    eq_expr_value, higher, match_def_path, meets_msrv, multispan_sugg, paths, snippet, span_lint_and_then,
 };
 
 use if_chain::if_chain;
@@ -92,7 +92,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualStrip {
                 } else {
                     return;
                 };
-                let target_res = qpath_res(cx, &target_path, target_arg.hir_id);
+                let target_res = cx.qpath_res(&target_path, target_arg.hir_id);
                 if target_res == Res::Err {
                     return;
                 };
@@ -221,7 +221,7 @@ fn find_stripping<'tcx>(
                 if let ExprKind::Index(indexed, index) = &unref.kind;
                 if let Some(higher::Range { start, end, .. }) = higher::range(index);
                 if let ExprKind::Path(path) = &indexed.kind;
-                if qpath_res(self.cx, path, ex.hir_id) == self.target;
+                if self.cx.qpath_res(path, ex.hir_id) == self.target;
                 then {
                     match (self.strip_kind, start, end) {
                         (StripKind::Prefix, Some(start), None) => {
@@ -235,7 +235,7 @@ fn find_stripping<'tcx>(
                                 if let ExprKind::Binary(Spanned { node: BinOpKind::Sub, .. }, left, right) = end.kind;
                                 if let Some(left_arg) = len_arg(self.cx, left);
                                 if let ExprKind::Path(left_path) = &left_arg.kind;
-                                if qpath_res(self.cx, left_path, left_arg.hir_id) == self.target;
+                                if self.cx.qpath_res(left_path, left_arg.hir_id) == self.target;
                                 if eq_pattern_length(self.cx, self.pattern, right);
                                 then {
                                     self.results.push(ex.span);
diff --git a/clippy_lints/src/mem_forget.rs b/clippy_lints/src/mem_forget.rs
index 8c6fd10f98a1e..d34f9761e26f9 100644
--- a/clippy_lints/src/mem_forget.rs
+++ b/clippy_lints/src/mem_forget.rs
@@ -1,4 +1,4 @@
-use crate::utils::{match_def_path, paths, qpath_res, span_lint};
+use crate::utils::{match_def_path, paths, span_lint};
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -29,7 +29,7 @@ impl<'tcx> LateLintPass<'tcx> for MemForget {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         if let ExprKind::Call(ref path_expr, ref args) = e.kind {
             if let ExprKind::Path(ref qpath) = path_expr.kind {
-                if let Some(def_id) = qpath_res(cx, qpath, path_expr.hir_id).opt_def_id() {
+                if let Some(def_id) = cx.qpath_res(qpath, path_expr.hir_id).opt_def_id() {
                     if match_def_path(cx, def_id, &paths::MEM_FORGET) {
                         let forgot_ty = cx.typeck_results().expr_ty(&args[0]);
 
diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index b1b5b3439a0e3..69302d695ce0a 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -1,4 +1,4 @@
-use crate::utils::{has_drop, qpath_res, snippet_opt, span_lint, span_lint_and_sugg};
+use crate::utils::{has_drop, snippet_opt, span_lint, span_lint_and_sugg};
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{BinOpKind, BlockCheckMode, Expr, ExprKind, Stmt, StmtKind, UnsafeSource};
@@ -67,7 +67,7 @@ fn has_no_effect(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
         },
         ExprKind::Call(ref callee, ref args) => {
             if let ExprKind::Path(ref qpath) = callee.kind {
-                let res = qpath_res(cx, qpath, callee.hir_id);
+                let res = cx.qpath_res(qpath, callee.hir_id);
                 match res {
                     Res::Def(DefKind::Struct | DefKind::Variant | DefKind::Ctor(..), ..) => {
                         !has_drop(cx, cx.typeck_results().expr_ty(expr))
@@ -146,7 +146,7 @@ fn reduce_expression<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<Vec
         },
         ExprKind::Call(ref callee, ref args) => {
             if let ExprKind::Path(ref qpath) = callee.kind {
-                let res = qpath_res(cx, qpath, callee.hir_id);
+                let res = cx.qpath_res(qpath, callee.hir_id);
                 match res {
                     Res::Def(DefKind::Struct | DefKind::Variant | DefKind::Ctor(..), ..)
                         if !has_drop(cx, cx.typeck_results().expr_ty(expr)) =>
diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs
index 3a9aa6ced03ba..f57d753631755 100644
--- a/clippy_lints/src/non_copy_const.rs
+++ b/clippy_lints/src/non_copy_const.rs
@@ -18,7 +18,7 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{InnerSpan, Span, DUMMY_SP};
 use rustc_typeck::hir_ty_to_ty;
 
-use crate::utils::{in_constant, qpath_res, span_lint_and_then};
+use crate::utils::{in_constant, span_lint_and_then};
 use if_chain::if_chain;
 
 // FIXME: this is a correctness problem but there's no suitable
@@ -339,7 +339,7 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst {
             }
 
             // Make sure it is a const item.
-            let item_def_id = match qpath_res(cx, qpath, expr.hir_id) {
+            let item_def_id = match cx.qpath_res(qpath, expr.hir_id) {
                 Res::Def(DefKind::Const | DefKind::AssocConst, did) => did,
                 _ => return,
             };
diff --git a/clippy_lints/src/to_string_in_display.rs b/clippy_lints/src/to_string_in_display.rs
index c53727ba16004..fa508df865e48 100644
--- a/clippy_lints/src/to_string_in_display.rs
+++ b/clippy_lints/src/to_string_in_display.rs
@@ -1,4 +1,4 @@
-use crate::utils::{match_def_path, match_trait_method, paths, qpath_res, span_lint};
+use crate::utils::{match_def_path, match_trait_method, paths, span_lint};
 use if_chain::if_chain;
 use rustc_hir::def::Res;
 use rustc_hir::{Expr, ExprKind, HirId, Impl, ImplItem, ImplItemKind, Item, ItemKind};
@@ -94,7 +94,7 @@ impl LateLintPass<'_> for ToStringInDisplay {
             if match_trait_method(cx, expr, &paths::TO_STRING);
             if self.in_display_impl;
             if let ExprKind::Path(ref qpath) = args[0].kind;
-            if let Res::Local(hir_id) = qpath_res(cx, qpath, args[0].hir_id);
+            if let Res::Local(hir_id) = cx.qpath_res(qpath, args[0].hir_id);
             if let Some(self_hir_id) = self.self_hir_id;
             if hir_id == self_hir_id;
             then {
diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 3b5a83d2a0bec..624ea16f585d2 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -34,7 +34,7 @@ use crate::utils::sugg::Sugg;
 use crate::utils::{
     clip, comparisons, differing_macro_contexts, higher, in_constant, indent_of, int_bits, is_hir_ty_cfg_dependant,
     is_type_diagnostic_item, last_path_segment, match_def_path, match_path, meets_msrv, method_chain_args,
-    multispan_sugg, numeric_literal::NumericLiteral, qpath_res, reindent_multiline, sext, snippet, snippet_opt,
+    multispan_sugg, numeric_literal::NumericLiteral, reindent_multiline, sext, snippet, snippet_opt,
     snippet_with_applicability, snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg,
     span_lint_and_then, unsext,
 };
@@ -298,7 +298,7 @@ fn match_type_parameter(cx: &LateContext<'_>, qpath: &QPath<'_>, path: &[&str])
             _ => None,
         });
         if let TyKind::Path(ref qpath) = ty.kind;
-        if let Some(did) = qpath_res(cx, qpath, ty.hir_id).opt_def_id();
+        if let Some(did) = cx.qpath_res(qpath, ty.hir_id).opt_def_id();
         if match_def_path(cx, did, path);
         then {
             return Some(ty.span);
@@ -365,7 +365,7 @@ impl Types {
         match hir_ty.kind {
             TyKind::Path(ref qpath) if !is_local => {
                 let hir_id = hir_ty.hir_id;
-                let res = qpath_res(cx, qpath, hir_id);
+                let res = cx.qpath_res(qpath, hir_id);
                 if let Some(def_id) = res.opt_def_id() {
                     if Some(def_id) == cx.tcx.lang_items().owned_box() {
                         if let Some(span) = match_borrows_parameter(cx, qpath) {
@@ -535,7 +535,7 @@ impl Types {
                             });
                             // ty is now _ at this point
                             if let TyKind::Path(ref ty_qpath) = ty.kind;
-                            let res = qpath_res(cx, ty_qpath, ty.hir_id);
+                            let res = cx.qpath_res(ty_qpath, ty.hir_id);
                             if let Some(def_id) = res.opt_def_id();
                             if Some(def_id) == cx.tcx.lang_items().owned_box();
                             // At this point, we know ty is Box<T>, now get T
@@ -652,7 +652,7 @@ impl Types {
         match mut_ty.ty.kind {
             TyKind::Path(ref qpath) => {
                 let hir_id = mut_ty.ty.hir_id;
-                let def = qpath_res(cx, qpath, hir_id);
+                let def = cx.qpath_res(qpath, hir_id);
                 if_chain! {
                     if let Some(def_id) = def.opt_def_id();
                     if Some(def_id) == cx.tcx.lang_items().owned_box();
@@ -739,7 +739,7 @@ fn is_any_trait(t: &hir::Ty<'_>) -> bool {
 
 fn get_bounds_if_impl_trait<'tcx>(cx: &LateContext<'tcx>, qpath: &QPath<'_>, id: HirId) -> Option<GenericBounds<'tcx>> {
     if_chain! {
-        if let Some(did) = qpath_res(cx, qpath, id).opt_def_id();
+        if let Some(did) = cx.qpath_res(qpath, id).opt_def_id();
         if let Some(Node::GenericParam(generic_param)) = cx.tcx.hir().get_if_local(did);
         if let GenericParamKind::Type { synthetic, .. } = generic_param.kind;
         if synthetic == Some(SyntheticTyParamKind::ImplTrait);
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 7aa17520ba79f..822863ca3e279 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -1,7 +1,7 @@
 use crate::consts::{constant_simple, Constant};
 use crate::utils::{
-    is_expn_of, match_def_path, match_qpath, match_type, method_calls, path_to_res, paths, qpath_res, run_lints,
-    snippet, span_lint, span_lint_and_help, span_lint_and_sugg, SpanlessEq,
+    is_expn_of, match_def_path, match_qpath, match_type, method_calls, path_to_res, paths, run_lints, snippet,
+    span_lint, span_lint_and_help, span_lint_and_sugg, SpanlessEq,
 };
 use if_chain::if_chain;
 use rustc_ast::ast::{Crate as AstCrate, ItemKind, LitKind, NodeId};
@@ -787,7 +787,7 @@ fn path_to_matched_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<Ve
 
     match &expr.kind {
         ExprKind::AddrOf(.., expr) => return path_to_matched_type(cx, expr),
-        ExprKind::Path(qpath) => match qpath_res(cx, qpath, expr.hir_id) {
+        ExprKind::Path(qpath) => match cx.qpath_res(qpath, expr.hir_id) {
             Res::Local(hir_id) => {
                 let parent_id = cx.tcx.hir().get_parent_node(hir_id);
                 if let Some(Node::Local(local)) = cx.tcx.hir().find(parent_id) {
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 9b262517a9834..023fb0a7112c1 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -370,19 +370,6 @@ pub fn path_to_res(cx: &LateContext<'_>, path: &[&str]) -> Option<def::Res> {
     }
 }
 
-pub fn qpath_res(cx: &LateContext<'_>, qpath: &hir::QPath<'_>, id: hir::HirId) -> Res {
-    match qpath {
-        hir::QPath::Resolved(_, path) => path.res,
-        hir::QPath::TypeRelative(..) | hir::QPath::LangItem(..) => {
-            if cx.tcx.has_typeck_results(id.owner.to_def_id()) {
-                cx.tcx.typeck(id.owner).qpath_res(qpath, id)
-            } else {
-                Res::Err
-            }
-        },
-    }
-}
-
 /// Convenience function to get the `DefId` of a trait by path.
 /// It could be a trait or trait alias.
 pub fn get_trait_def_id(cx: &LateContext<'_>, path: &[&str]) -> Option<DefId> {

From e33ab3fdd85e162909f884a2437cb42ce6e794cf Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Mon, 18 Jan 2021 22:33:25 +0100
Subject: [PATCH 041/108] Add test for `needless_return` lint

---
 tests/ui/needless_return.fixed  | 6 ++++++
 tests/ui/needless_return.rs     | 6 ++++++
 tests/ui/needless_return.stderr | 8 +++++++-
 3 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/tests/ui/needless_return.fixed b/tests/ui/needless_return.fixed
index f137e8ecae935..990475fcb587e 100644
--- a/tests/ui/needless_return.fixed
+++ b/tests/ui/needless_return.fixed
@@ -112,6 +112,12 @@ mod issue6501 {
         };
         let _ = || {};
     }
+
+    struct Foo;
+    #[allow(clippy::unnecessary_lazy_evaluations)]
+    fn bar(res: Result<Foo, u8>) -> Foo {
+        res.unwrap_or_else(|_| Foo)
+    }
 }
 
 fn main() {
diff --git a/tests/ui/needless_return.rs b/tests/ui/needless_return.rs
index d754e4d37a844..dec3d84a02046 100644
--- a/tests/ui/needless_return.rs
+++ b/tests/ui/needless_return.rs
@@ -112,6 +112,12 @@ mod issue6501 {
         };
         let _ = || return;
     }
+
+    struct Foo;
+    #[allow(clippy::unnecessary_lazy_evaluations)]
+    fn bar(res: Result<Foo, u8>) -> Foo {
+        res.unwrap_or_else(|_| return Foo)
+    }
 }
 
 fn main() {
diff --git a/tests/ui/needless_return.stderr b/tests/ui/needless_return.stderr
index d1240e161c07e..ae31d6075416e 100644
--- a/tests/ui/needless_return.stderr
+++ b/tests/ui/needless_return.stderr
@@ -102,5 +102,11 @@ error: unneeded `return` statement
 LL |         let _ = || return;
    |                    ^^^^^^ help: replace `return` with an empty block: `{}`
 
-error: aborting due to 17 previous errors
+error: unneeded `return` statement
+  --> $DIR/needless_return.rs:119:32
+   |
+LL |         res.unwrap_or_else(|_| return Foo)
+   |                                ^^^^^^^^^^ help: remove `return`: `Foo`
+
+error: aborting due to 18 previous errors
 

From c53192c34762f8104542168dbc7c83cdd280151c Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Tue, 19 Jan 2021 12:46:24 +1300
Subject: [PATCH 042/108] Add a note to `as_conversions`
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

… to clalify its purpose.
---
 clippy_lints/src/as_conversions.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/clippy_lints/src/as_conversions.rs b/clippy_lints/src/as_conversions.rs
index 0c8efd755146e..c30d65bbc5704 100644
--- a/clippy_lints/src/as_conversions.rs
+++ b/clippy_lints/src/as_conversions.rs
@@ -8,6 +8,14 @@ use crate::utils::span_lint_and_help;
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `as` conversions.
     ///
+    /// Note that this lint is specialized in linting *every single* use of `as`
+    /// regardless of whether good alternatives exist or not.
+    /// If you want more precise lints for `as`, please consider using these separate lints:
+    /// `unnecessary_cast`, `cast_lossless/possible_truncation/possible_wrap/precision_loss/sign_loss`,
+    /// `fn_to_numeric_cast(_with_truncation)`, `char_lit_as_u8`, `ref_to_mut` and `ptr_as_ptr`.
+    /// There is a good explanation the reason why this lint should work in this way and how it is useful
+    /// [in this issue](https://github.com/rust-lang/rust-clippy/issues/5122).
+    ///
     /// **Why is this bad?** `as` conversions will perform many kinds of
     /// conversions, including silently lossy conversions and dangerous coercions.
     /// There are cases when it makes sense to use `as`, so the lint is

From 3269070261e8324c2b3074cd491ddf2ac6cf19d3 Mon Sep 17 00:00:00 2001
From: nahuakang <kangnahua@gmail.com>
Date: Mon, 11 Jan 2021 23:56:12 +0100
Subject: [PATCH 043/108] Create new lint for the usage of inspect for each.

---
 CHANGELOG.md                                 |  1 +
 clippy_lints/src/lib.rs                      |  3 ++
 clippy_lints/src/methods/inspect_for_each.rs | 23 ++++++++++++++
 clippy_lints/src/methods/mod.rs              | 33 ++++++++++++++++++++
 tests/ui/inspect_for_each.rs                 | 22 +++++++++++++
 tests/ui/inspect_for_each.stderr             | 16 ++++++++++
 6 files changed, 98 insertions(+)
 create mode 100644 clippy_lints/src/methods/inspect_for_each.rs
 create mode 100644 tests/ui/inspect_for_each.rs
 create mode 100644 tests/ui/inspect_for_each.stderr

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 64864c2e2780d..a91b7c64770b9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1996,6 +1996,7 @@ Released 2018-09-13
 [`inline_asm_x86_att_syntax`]: https://rust-lang.github.io/rust-clippy/master/index.html#inline_asm_x86_att_syntax
 [`inline_asm_x86_intel_syntax`]: https://rust-lang.github.io/rust-clippy/master/index.html#inline_asm_x86_intel_syntax
 [`inline_fn_without_body`]: https://rust-lang.github.io/rust-clippy/master/index.html#inline_fn_without_body
+[`inspect_for_each`]: https://rust-lang.github.io/rust-clippy/master/index.html#inspect_for_each
 [`int_plus_one`]: https://rust-lang.github.io/rust-clippy/master/index.html#int_plus_one
 [`integer_arithmetic`]: https://rust-lang.github.io/rust-clippy/master/index.html#integer_arithmetic
 [`integer_division`]: https://rust-lang.github.io/rust-clippy/master/index.html#integer_division
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index f12994c7a605e..17662b81205cc 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -733,6 +733,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &methods::FROM_ITER_INSTEAD_OF_COLLECT,
         &methods::GET_UNWRAP,
         &methods::INEFFICIENT_TO_STRING,
+        &methods::INSPECT_FOR_EACH,
         &methods::INTO_ITER_ON_REF,
         &methods::ITERATOR_STEP_BY_ZERO,
         &methods::ITER_CLONED_COLLECT,
@@ -1507,6 +1508,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::FILTER_NEXT),
         LintId::of(&methods::FLAT_MAP_IDENTITY),
         LintId::of(&methods::FROM_ITER_INSTEAD_OF_COLLECT),
+        LintId::of(&methods::INSPECT_FOR_EACH),
         LintId::of(&methods::INTO_ITER_ON_REF),
         LintId::of(&methods::ITERATOR_STEP_BY_ZERO),
         LintId::of(&methods::ITER_CLONED_COLLECT),
@@ -1807,6 +1809,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::CLONE_ON_COPY),
         LintId::of(&methods::FILTER_NEXT),
         LintId::of(&methods::FLAT_MAP_IDENTITY),
+        LintId::of(&methods::INSPECT_FOR_EACH),
         LintId::of(&methods::OPTION_AS_REF_DEREF),
         LintId::of(&methods::SEARCH_IS_SOME),
         LintId::of(&methods::SKIP_WHILE_NEXT),
diff --git a/clippy_lints/src/methods/inspect_for_each.rs b/clippy_lints/src/methods/inspect_for_each.rs
new file mode 100644
index 0000000000000..6d41ee38a2767
--- /dev/null
+++ b/clippy_lints/src/methods/inspect_for_each.rs
@@ -0,0 +1,23 @@
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_span::source_map::Span;
+
+use crate::utils::{match_trait_method, paths, span_lint_and_help};
+
+use super::INSPECT_FOR_EACH;
+
+/// lint use of `inspect().for_each()` for `Iterators`
+pub(super) fn lint<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, inspect_span: Span) {
+    if match_trait_method(cx, expr, &paths::ITERATOR) {
+        let msg = "called `inspect(..).for_each(..)` on an `Iterator`";
+        let hint = "move the code from `inspect(..)` to `for_each(..)` and remove the `inspect(..)`";
+        span_lint_and_help(
+            cx,
+            INSPECT_FOR_EACH,
+            inspect_span.with_hi(expr.span.hi()),
+            msg,
+            None,
+            hint,
+        );
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index f13f2491d6e96..018696ef0cf04 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1,5 +1,6 @@
 mod bind_instead_of_map;
 mod inefficient_to_string;
+mod inspect_for_each;
 mod manual_saturating_arithmetic;
 mod option_map_unwrap_or;
 mod unnecessary_filter_map;
@@ -1405,6 +1406,36 @@ declare_clippy_lint! {
     "use `.collect()` instead of `::from_iter()`"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for usage of `inspect().for_each()`.
+    ///
+    /// **Why is this bad?** It is the same as performing the computation
+    /// inside `inspect` at the beginning of the closure in `for_each`.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// [1,2,3,4,5].iter()
+    /// .inspect(|&x| println!("inspect the number: {}", x))
+    /// .for_each(|&x| {
+    ///     assert!(x >= 0);
+    /// });
+    /// ```
+    /// Can be written as
+    /// ```rust
+    /// [1,2,3,4,5].iter()
+    /// .for_each(|&x| {
+    ///     println!("inspect the number: {}", x);
+    ///     assert!(x >= 0);
+    /// });
+    /// ```
+    pub INSPECT_FOR_EACH,
+    complexity,
+    "using `.inspect().for_each()`, which can be replaced with `.for_each()`"
+}
+
 pub struct Methods {
     msrv: Option<RustcVersion>,
 }
@@ -1467,6 +1498,7 @@ impl_lint_pass!(Methods => [
     UNNECESSARY_LAZY_EVALUATIONS,
     MAP_COLLECT_RESULT_UNIT,
     FROM_ITER_INSTEAD_OF_COLLECT,
+    INSPECT_FOR_EACH,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Methods {
@@ -1553,6 +1585,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["get_or_insert_with", ..] => unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], "get_or_insert"),
             ["ok_or_else", ..] => unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], "ok_or"),
             ["collect", "map"] => lint_map_collect(cx, expr, arg_lists[1], arg_lists[0]),
+            ["for_each", "inspect"] => inspect_for_each::lint(cx, expr, method_spans[1]),
             _ => {},
         }
 
diff --git a/tests/ui/inspect_for_each.rs b/tests/ui/inspect_for_each.rs
new file mode 100644
index 0000000000000..7fe45c83bcacb
--- /dev/null
+++ b/tests/ui/inspect_for_each.rs
@@ -0,0 +1,22 @@
+#![warn(clippy::inspect_for_each)]
+
+fn main() {
+    let a: Vec<usize> = vec![1, 2, 3, 4, 5];
+
+    let mut b: Vec<usize> = Vec::new();
+    a.into_iter().inspect(|x| assert!(*x > 0)).for_each(|x| {
+        let y = do_some(x);
+        let z = do_more(y);
+        b.push(z);
+    });
+
+    assert_eq!(b, vec![4, 5, 6, 7, 8]);
+}
+
+fn do_some(a: usize) -> usize {
+    a + 1
+}
+
+fn do_more(a: usize) -> usize {
+    a + 2
+}
diff --git a/tests/ui/inspect_for_each.stderr b/tests/ui/inspect_for_each.stderr
new file mode 100644
index 0000000000000..9f976bb74584e
--- /dev/null
+++ b/tests/ui/inspect_for_each.stderr
@@ -0,0 +1,16 @@
+error: called `inspect(..).for_each(..)` on an `Iterator`
+  --> $DIR/inspect_for_each.rs:7:19
+   |
+LL |       a.into_iter().inspect(|x| assert!(*x > 0)).for_each(|x| {
+   |  ___________________^
+LL | |         let y = do_some(x);
+LL | |         let z = do_more(y);
+LL | |         b.push(z);
+LL | |     });
+   | |______^
+   |
+   = note: `-D clippy::inspect-for-each` implied by `-D warnings`
+   = help: move the code from `inspect(..)` to `for_each(..)` and remove the `inspect(..)`
+
+error: aborting due to previous error
+

From 966320642b157c539901ed0461d6aab6cb34729d Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Tue, 19 Jan 2021 23:51:10 +0900
Subject: [PATCH 044/108] Fix a wrong suggestion of `ref_in_deref`

---
 clippy_lints/src/reference.rs   | 10 ++++++++--
 tests/ui/unnecessary_ref.fixed  | 11 ++++++++++-
 tests/ui/unnecessary_ref.rs     | 11 ++++++++++-
 tests/ui/unnecessary_ref.stderr | 10 +++++++++-
 4 files changed, 37 insertions(+), 5 deletions(-)

diff --git a/clippy_lints/src/reference.rs b/clippy_lints/src/reference.rs
index efe3237990d43..2dfb947b5eb9a 100644
--- a/clippy_lints/src/reference.rs
+++ b/clippy_lints/src/reference.rs
@@ -1,3 +1,4 @@
+use crate::utils::sugg::Sugg;
 use crate::utils::{in_macro, snippet_opt, snippet_with_applicability, span_lint_and_sugg};
 use if_chain::if_chain;
 use rustc_ast::ast::{Expr, ExprKind, Mutability, UnOp};
@@ -124,14 +125,19 @@ impl EarlyLintPass for RefInDeref {
             if let ExprKind::Paren(ref parened) = object.kind;
             if let ExprKind::AddrOf(_, _, ref inner) = parened.kind;
             then {
-                let mut applicability = Applicability::MachineApplicable;
+                let applicability = if inner.span.from_expansion() {
+                    Applicability::MaybeIncorrect
+                } else {
+                    Applicability::MachineApplicable
+                };
+                let sugg = Sugg::ast(cx, inner, "_").maybe_par();
                 span_lint_and_sugg(
                     cx,
                     REF_IN_DEREF,
                     object.span,
                     "creating a reference that is immediately dereferenced",
                     "try this",
-                    snippet_with_applicability(cx, inner.span, "_", &mut applicability).to_string(),
+                    sugg.to_string(),
                     applicability,
                 );
             }
diff --git a/tests/ui/unnecessary_ref.fixed b/tests/ui/unnecessary_ref.fixed
index f7b94118d4e86..d927bae976f79 100644
--- a/tests/ui/unnecessary_ref.fixed
+++ b/tests/ui/unnecessary_ref.fixed
@@ -1,7 +1,7 @@
 // run-rustfix
 
 #![feature(stmt_expr_attributes)]
-#![allow(unused_variables)]
+#![allow(unused_variables, dead_code)]
 
 struct Outer {
     inner: u32,
@@ -12,3 +12,12 @@ fn main() {
     let outer = Outer { inner: 0 };
     let inner = outer.inner;
 }
+
+struct Apple;
+impl Apple {
+    fn hello(&self) {}
+}
+struct Package(pub *const Apple);
+fn foobar(package: *const Package) {
+    unsafe { &*(*package).0 }.hello();
+}
diff --git a/tests/ui/unnecessary_ref.rs b/tests/ui/unnecessary_ref.rs
index 4e585b9b96ba9..86bfb76ec2619 100644
--- a/tests/ui/unnecessary_ref.rs
+++ b/tests/ui/unnecessary_ref.rs
@@ -1,7 +1,7 @@
 // run-rustfix
 
 #![feature(stmt_expr_attributes)]
-#![allow(unused_variables)]
+#![allow(unused_variables, dead_code)]
 
 struct Outer {
     inner: u32,
@@ -12,3 +12,12 @@ fn main() {
     let outer = Outer { inner: 0 };
     let inner = (&outer).inner;
 }
+
+struct Apple;
+impl Apple {
+    fn hello(&self) {}
+}
+struct Package(pub *const Apple);
+fn foobar(package: *const Package) {
+    unsafe { &*(&*package).0 }.hello();
+}
diff --git a/tests/ui/unnecessary_ref.stderr b/tests/ui/unnecessary_ref.stderr
index d0a0f219097e5..436f4bcf73804 100644
--- a/tests/ui/unnecessary_ref.stderr
+++ b/tests/ui/unnecessary_ref.stderr
@@ -10,5 +10,13 @@ note: the lint level is defined here
 LL | #[deny(clippy::ref_in_deref)]
    |        ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: creating a reference that is immediately dereferenced
+  --> $DIR/unnecessary_ref.rs:22:16
+   |
+LL |     unsafe { &*(&*package).0 }.hello();
+   |                ^^^^^^^^^^^ help: try this: `(*package)`
+   |
+   = note: `-D clippy::ref-in-deref` implied by `-D warnings`
+
+error: aborting due to 2 previous errors
 

From 391bb218b5a79f32ddfacc668838fdfb06835f77 Mon Sep 17 00:00:00 2001
From: Marijn Suijten <marijn@traverseresearch.nl>
Date: Tue, 19 Jan 2021 19:20:26 +0100
Subject: [PATCH 045/108] size_of_in_element_count: Separate test file in
 expressions and functions

An upcoming test case for new expresssion variants make the stderr file
go over 200 lines. Split this test case in two to have a clear
distinction between checking whether the lint is still applying on
all the functions with member counts as argument, versus validating
various member-count expressions that may or may not be invalid.
---
 .../size_of_in_element_count/expressions.rs   | 28 ++++++++
 .../expressions.stderr                        | 27 ++++++++
 .../functions.rs}                             | 15 ----
 .../functions.stderr}                         | 68 ++++++-------------
 4 files changed, 77 insertions(+), 61 deletions(-)
 create mode 100644 tests/ui/size_of_in_element_count/expressions.rs
 create mode 100644 tests/ui/size_of_in_element_count/expressions.stderr
 rename tests/ui/{size_of_in_element_count.rs => size_of_in_element_count/functions.rs} (71%)
 rename tests/ui/{size_of_in_element_count.stderr => size_of_in_element_count/functions.stderr} (75%)

diff --git a/tests/ui/size_of_in_element_count/expressions.rs b/tests/ui/size_of_in_element_count/expressions.rs
new file mode 100644
index 0000000000000..b56910917ba85
--- /dev/null
+++ b/tests/ui/size_of_in_element_count/expressions.rs
@@ -0,0 +1,28 @@
+#![warn(clippy::size_of_in_element_count)]
+#![allow(clippy::ptr_offset_with_cast)]
+
+use std::mem::{size_of, size_of_val};
+use std::ptr::{copy, copy_nonoverlapping, write_bytes};
+
+fn main() {
+    const SIZE: usize = 128;
+    const HALF_SIZE: usize = SIZE / 2;
+    const DOUBLE_SIZE: usize = SIZE * 2;
+    let mut x = [2u8; SIZE];
+    let mut y = [2u8; SIZE];
+
+    // Count expression involving multiplication of size_of (Should trigger the lint)
+    unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE) };
+
+    // Count expression involving nested multiplications of size_of (Should trigger the lint)
+    unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), HALF_SIZE * size_of_val(&x[0]) * 2) };
+
+    // Count expression involving divisions of size_of (Should trigger the lint)
+    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE * size_of::<u8>() / 2) };
+
+    // No size_of calls (Should not trigger the lint)
+    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), SIZE) };
+
+    // Different types for pointee and size_of (Should not trigger the lint)
+    unsafe { y.as_mut_ptr().write_bytes(0u8, size_of::<u16>() / 2 * SIZE) };
+}
diff --git a/tests/ui/size_of_in_element_count/expressions.stderr b/tests/ui/size_of_in_element_count/expressions.stderr
new file mode 100644
index 0000000000000..47b98e9d94740
--- /dev/null
+++ b/tests/ui/size_of_in_element_count/expressions.stderr
@@ -0,0 +1,27 @@
+error: found a count of bytes instead of a count of elements of `T`
+  --> $DIR/expressions.rs:15:62
+   |
+LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE) };
+   |                                                              ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::size-of-in-element-count` implied by `-D warnings`
+   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
+
+error: found a count of bytes instead of a count of elements of `T`
+  --> $DIR/expressions.rs:18:62
+   |
+LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), HALF_SIZE * size_of_val(&x[0]) * 2) };
+   |                                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
+
+error: found a count of bytes instead of a count of elements of `T`
+  --> $DIR/expressions.rs:21:47
+   |
+LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE * size_of::<u8>() / 2) };
+   |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
+
+error: aborting due to 3 previous errors
+
diff --git a/tests/ui/size_of_in_element_count.rs b/tests/ui/size_of_in_element_count/functions.rs
similarity index 71%
rename from tests/ui/size_of_in_element_count.rs
rename to tests/ui/size_of_in_element_count/functions.rs
index b13e390705ab7..09d08ac37dce5 100644
--- a/tests/ui/size_of_in_element_count.rs
+++ b/tests/ui/size_of_in_element_count/functions.rs
@@ -43,19 +43,4 @@ fn main() {
     y.as_mut_ptr().wrapping_add(size_of::<u8>());
     unsafe { y.as_ptr().offset(size_of::<u8>() as isize) };
     y.as_mut_ptr().wrapping_offset(size_of::<u8>() as isize);
-
-    // Count expression involving multiplication of size_of (Should trigger the lint)
-    unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE) };
-
-    // Count expression involving nested multiplications of size_of (Should trigger the lint)
-    unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), HALF_SIZE * size_of_val(&x[0]) * 2) };
-
-    // Count expression involving divisions of size_of (Should trigger the lint)
-    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE * size_of::<u8>() / 2) };
-
-    // No size_of calls (Should not trigger the lint)
-    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), SIZE) };
-
-    // Different types for pointee and size_of (Should not trigger the lint)
-    unsafe { y.as_mut_ptr().write_bytes(0u8, size_of::<u16>() / 2 * SIZE) };
 }
diff --git a/tests/ui/size_of_in_element_count.stderr b/tests/ui/size_of_in_element_count/functions.stderr
similarity index 75%
rename from tests/ui/size_of_in_element_count.stderr
rename to tests/ui/size_of_in_element_count/functions.stderr
index 8cf3612abda36..c1e824167b7f3 100644
--- a/tests/ui/size_of_in_element_count.stderr
+++ b/tests/ui/size_of_in_element_count/functions.stderr
@@ -1,5 +1,5 @@
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:18:68
+  --> $DIR/functions.rs:18:68
    |
 LL |     unsafe { copy_nonoverlapping::<u8>(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>()) };
    |                                                                    ^^^^^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL |     unsafe { copy_nonoverlapping::<u8>(x.as_ptr(), y.as_mut_ptr(), size_of:
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:19:62
+  --> $DIR/functions.rs:19:62
    |
 LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
    |                                                              ^^^^^^^^^^^^^^^^^^
@@ -16,7 +16,7 @@ LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:21:49
+  --> $DIR/functions.rs:21:49
    |
 LL |     unsafe { x.as_ptr().copy_to(y.as_mut_ptr(), size_of::<u8>()) };
    |                                                 ^^^^^^^^^^^^^^^
@@ -24,7 +24,7 @@ LL |     unsafe { x.as_ptr().copy_to(y.as_mut_ptr(), size_of::<u8>()) };
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:22:64
+  --> $DIR/functions.rs:22:64
    |
 LL |     unsafe { x.as_ptr().copy_to_nonoverlapping(y.as_mut_ptr(), size_of::<u8>()) };
    |                                                                ^^^^^^^^^^^^^^^
@@ -32,7 +32,7 @@ LL |     unsafe { x.as_ptr().copy_to_nonoverlapping(y.as_mut_ptr(), size_of::<u8
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:23:51
+  --> $DIR/functions.rs:23:51
    |
 LL |     unsafe { y.as_mut_ptr().copy_from(x.as_ptr(), size_of::<u8>()) };
    |                                                   ^^^^^^^^^^^^^^^
@@ -40,7 +40,7 @@ LL |     unsafe { y.as_mut_ptr().copy_from(x.as_ptr(), size_of::<u8>()) };
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:24:66
+  --> $DIR/functions.rs:24:66
    |
 LL |     unsafe { y.as_mut_ptr().copy_from_nonoverlapping(x.as_ptr(), size_of::<u8>()) };
    |                                                                  ^^^^^^^^^^^^^^^
@@ -48,7 +48,7 @@ LL |     unsafe { y.as_mut_ptr().copy_from_nonoverlapping(x.as_ptr(), size_of::<
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:26:47
+  --> $DIR/functions.rs:26:47
    |
 LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>()) };
    |                                               ^^^^^^^^^^^^^^^
@@ -56,7 +56,7 @@ LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>()) };
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:27:47
+  --> $DIR/functions.rs:27:47
    |
 LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
    |                                               ^^^^^^^^^^^^^^^^^^
@@ -64,7 +64,7 @@ LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:29:46
+  --> $DIR/functions.rs:29:46
    |
 LL |     unsafe { y.as_mut_ptr().write_bytes(0u8, size_of::<u8>() * SIZE) };
    |                                              ^^^^^^^^^^^^^^^^^^^^^^
@@ -72,7 +72,7 @@ LL |     unsafe { y.as_mut_ptr().write_bytes(0u8, size_of::<u8>() * SIZE) };
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:30:47
+  --> $DIR/functions.rs:30:47
    |
 LL |     unsafe { write_bytes(y.as_mut_ptr(), 0u8, size_of::<u8>() * SIZE) };
    |                                               ^^^^^^^^^^^^^^^^^^^^^^
@@ -80,7 +80,7 @@ LL |     unsafe { write_bytes(y.as_mut_ptr(), 0u8, size_of::<u8>() * SIZE) };
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:32:66
+  --> $DIR/functions.rs:32:66
    |
 LL |     unsafe { swap_nonoverlapping(y.as_mut_ptr(), x.as_mut_ptr(), size_of::<u8>() * SIZE) };
    |                                                                  ^^^^^^^^^^^^^^^^^^^^^^
@@ -88,7 +88,7 @@ LL |     unsafe { swap_nonoverlapping(y.as_mut_ptr(), x.as_mut_ptr(), size_of::<
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:34:46
+  --> $DIR/functions.rs:34:46
    |
 LL |     slice_from_raw_parts_mut(y.as_mut_ptr(), size_of::<u8>() * SIZE);
    |                                              ^^^^^^^^^^^^^^^^^^^^^^
@@ -96,7 +96,7 @@ LL |     slice_from_raw_parts_mut(y.as_mut_ptr(), size_of::<u8>() * SIZE);
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:35:38
+  --> $DIR/functions.rs:35:38
    |
 LL |     slice_from_raw_parts(y.as_ptr(), size_of::<u8>() * SIZE);
    |                                      ^^^^^^^^^^^^^^^^^^^^^^
@@ -104,7 +104,7 @@ LL |     slice_from_raw_parts(y.as_ptr(), size_of::<u8>() * SIZE);
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:37:49
+  --> $DIR/functions.rs:37:49
    |
 LL |     unsafe { from_raw_parts_mut(y.as_mut_ptr(), size_of::<u8>() * SIZE) };
    |                                                 ^^^^^^^^^^^^^^^^^^^^^^
@@ -112,7 +112,7 @@ LL |     unsafe { from_raw_parts_mut(y.as_mut_ptr(), size_of::<u8>() * SIZE) };
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:38:41
+  --> $DIR/functions.rs:38:41
    |
 LL |     unsafe { from_raw_parts(y.as_ptr(), size_of::<u8>() * SIZE) };
    |                                         ^^^^^^^^^^^^^^^^^^^^^^
@@ -120,7 +120,7 @@ LL |     unsafe { from_raw_parts(y.as_ptr(), size_of::<u8>() * SIZE) };
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:40:33
+  --> $DIR/functions.rs:40:33
    |
 LL |     unsafe { y.as_mut_ptr().sub(size_of::<u8>()) };
    |                                 ^^^^^^^^^^^^^^^
@@ -128,7 +128,7 @@ LL |     unsafe { y.as_mut_ptr().sub(size_of::<u8>()) };
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:41:29
+  --> $DIR/functions.rs:41:29
    |
 LL |     y.as_ptr().wrapping_sub(size_of::<u8>());
    |                             ^^^^^^^^^^^^^^^
@@ -136,7 +136,7 @@ LL |     y.as_ptr().wrapping_sub(size_of::<u8>());
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:42:29
+  --> $DIR/functions.rs:42:29
    |
 LL |     unsafe { y.as_ptr().add(size_of::<u8>()) };
    |                             ^^^^^^^^^^^^^^^
@@ -144,7 +144,7 @@ LL |     unsafe { y.as_ptr().add(size_of::<u8>()) };
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:43:33
+  --> $DIR/functions.rs:43:33
    |
 LL |     y.as_mut_ptr().wrapping_add(size_of::<u8>());
    |                                 ^^^^^^^^^^^^^^^
@@ -152,7 +152,7 @@ LL |     y.as_mut_ptr().wrapping_add(size_of::<u8>());
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:44:32
+  --> $DIR/functions.rs:44:32
    |
 LL |     unsafe { y.as_ptr().offset(size_of::<u8>() as isize) };
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -160,36 +160,12 @@ LL |     unsafe { y.as_ptr().offset(size_of::<u8>() as isize) };
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:45:36
+  --> $DIR/functions.rs:45:36
    |
 LL |     y.as_mut_ptr().wrapping_offset(size_of::<u8>() as isize);
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
-error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:48:62
-   |
-LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE) };
-   |                                                              ^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
-
-error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:51:62
-   |
-LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), HALF_SIZE * size_of_val(&x[0]) * 2) };
-   |                                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
-
-error: found a count of bytes instead of a count of elements of `T`
-  --> $DIR/size_of_in_element_count.rs:54:47
-   |
-LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE * size_of::<u8>() / 2) };
-   |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
-
-error: aborting due to 24 previous errors
+error: aborting due to 21 previous errors
 

From d4bf59b6ef24042653951b69105a3a68542f3bbd Mon Sep 17 00:00:00 2001
From: Marijn Suijten <marijn@traverseresearch.nl>
Date: Tue, 12 Jan 2021 11:35:44 +0100
Subject: [PATCH 046/108] size_of_in_element_count: Disable lint on division by
 byte-size

It is fairly common to divide some length in bytes by the byte-size of a
single element before creating a `from_raw_parts` slice or similar
operation. This lint would erroneously disallow such expressions.

Just in case, instead of simply disabling this lint in the RHS of a
division, keep track of the inversion and enable it again on recursive
division.
---
 clippy_lints/src/size_of_in_element_count.rs       | 14 +++++++++-----
 tests/ui/size_of_in_element_count/expressions.rs   |  9 +++++++++
 .../ui/size_of_in_element_count/expressions.stderr | 10 +++++++++-
 3 files changed, 27 insertions(+), 6 deletions(-)

diff --git a/clippy_lints/src/size_of_in_element_count.rs b/clippy_lints/src/size_of_in_element_count.rs
index ea7a76146f52c..87e386baadc54 100644
--- a/clippy_lints/src/size_of_in_element_count.rs
+++ b/clippy_lints/src/size_of_in_element_count.rs
@@ -35,10 +35,11 @@ declare_clippy_lint! {
 
 declare_lint_pass!(SizeOfInElementCount => [SIZE_OF_IN_ELEMENT_COUNT]);
 
-fn get_size_of_ty(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<Ty<'tcx>> {
+fn get_size_of_ty(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, inverted: bool) -> Option<Ty<'tcx>> {
     match expr.kind {
         ExprKind::Call(count_func, _func_args) => {
             if_chain! {
+                if !inverted;
                 if let ExprKind::Path(ref count_func_qpath) = count_func.kind;
                 if let Some(def_id) = cx.qpath_res(count_func_qpath, count_func.hir_id).opt_def_id();
                 if match_def_path(cx, def_id, &paths::MEM_SIZE_OF)
@@ -50,10 +51,13 @@ fn get_size_of_ty(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<Ty<'tc
                 }
             }
         },
-        ExprKind::Binary(op, left, right) if BinOpKind::Mul == op.node || BinOpKind::Div == op.node => {
-            get_size_of_ty(cx, left).or_else(|| get_size_of_ty(cx, right))
+        ExprKind::Binary(op, left, right) if BinOpKind::Mul == op.node => {
+            get_size_of_ty(cx, left, inverted).or_else(|| get_size_of_ty(cx, right, inverted))
         },
-        ExprKind::Cast(expr, _) => get_size_of_ty(cx, expr),
+        ExprKind::Binary(op, left, right) if BinOpKind::Div == op.node => {
+            get_size_of_ty(cx, left, inverted).or_else(|| get_size_of_ty(cx, right, !inverted))
+        },
+        ExprKind::Cast(expr, _) => get_size_of_ty(cx, expr, inverted),
         _ => None,
     }
 }
@@ -128,7 +132,7 @@ impl<'tcx> LateLintPass<'tcx> for SizeOfInElementCount {
 
             // Find a size_of call in the count parameter expression and
             // check that it's the same type
-            if let Some(ty_used_for_size_of) = get_size_of_ty(cx, count_expr);
+            if let Some(ty_used_for_size_of) = get_size_of_ty(cx, count_expr, false);
             if TyS::same_type(pointee_ty, ty_used_for_size_of);
             then {
                 span_lint_and_help(
diff --git a/tests/ui/size_of_in_element_count/expressions.rs b/tests/ui/size_of_in_element_count/expressions.rs
index b56910917ba85..2594e8fa6ad3e 100644
--- a/tests/ui/size_of_in_element_count/expressions.rs
+++ b/tests/ui/size_of_in_element_count/expressions.rs
@@ -20,6 +20,15 @@ fn main() {
     // Count expression involving divisions of size_of (Should trigger the lint)
     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE * size_of::<u8>() / 2) };
 
+    // Count expression involving divisions by size_of (Should not trigger the lint)
+    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE / size_of::<u8>()) };
+
+    // Count expression involving divisions by multiple size_of (Should not trigger the lint)
+    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE / (2 * size_of::<u8>())) };
+
+    // Count expression involving recursive divisions by size_of (Should trigger the lint)
+    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE / (2 / size_of::<u8>())) };
+
     // No size_of calls (Should not trigger the lint)
     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), SIZE) };
 
diff --git a/tests/ui/size_of_in_element_count/expressions.stderr b/tests/ui/size_of_in_element_count/expressions.stderr
index 47b98e9d94740..0f0dff57f51bd 100644
--- a/tests/ui/size_of_in_element_count/expressions.stderr
+++ b/tests/ui/size_of_in_element_count/expressions.stderr
@@ -23,5 +23,13 @@ LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE * size_of::<u8>()
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
-error: aborting due to 3 previous errors
+error: found a count of bytes instead of a count of elements of `T`
+  --> $DIR/expressions.rs:30:47
+   |
+LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE / (2 / size_of::<u8>())) };
+   |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
+
+error: aborting due to 4 previous errors
 

From 6c830ff9e4621c6e159ce8edb33fb225352e7b69 Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Sat, 19 Dec 2020 18:57:11 +0900
Subject: [PATCH 047/108] Run `cargo dev new_lint`

---
 CHANGELOG.md                             |  1 +
 clippy_lints/src/capitalized_acronyms.rs | 28 ++++++++++++++++++++++++
 clippy_lints/src/lib.rs                  |  2 ++
 tests/ui/capitalized_acronyms.rs         |  5 +++++
 4 files changed, 36 insertions(+)
 create mode 100644 clippy_lints/src/capitalized_acronyms.rs
 create mode 100644 tests/ui/capitalized_acronyms.rs

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b3adeed772067..963c9e77a18bc 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1877,6 +1877,7 @@ Released 2018-09-13
 [`box_vec`]: https://rust-lang.github.io/rust-clippy/master/index.html#box_vec
 [`boxed_local`]: https://rust-lang.github.io/rust-clippy/master/index.html#boxed_local
 [`builtin_type_shadow`]: https://rust-lang.github.io/rust-clippy/master/index.html#builtin_type_shadow
+[`capitalized_acronyms`]: https://rust-lang.github.io/rust-clippy/master/index.html#capitalized_acronyms
 [`cargo_common_metadata`]: https://rust-lang.github.io/rust-clippy/master/index.html#cargo_common_metadata
 [`case_sensitive_file_extension_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#case_sensitive_file_extension_comparisons
 [`cast_lossless`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
diff --git a/clippy_lints/src/capitalized_acronyms.rs b/clippy_lints/src/capitalized_acronyms.rs
new file mode 100644
index 0000000000000..835e92dc04bce
--- /dev/null
+++ b/clippy_lints/src/capitalized_acronyms.rs
@@ -0,0 +1,28 @@
+use rustc_lint::{EarlyLintPass, EarlyContext};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_ast::ast::*;
+
+declare_clippy_lint! {
+    /// **What it does:**
+    ///
+    /// **Why is this bad?**
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// // example code where clippy issues a warning
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// // example code which does not raise clippy warning
+    /// ```
+    pub CAPITALIZED_ACRONYMS,
+    style,
+    "default lint description"
+}
+
+declare_lint_pass!(CapitalizedAcronyms => [CAPITALIZED_ACRONYMS]);
+
+impl EarlyLintPass for CapitalizedAcronyms {}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 0b1b347ce4232..a236e1b54bbc9 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -169,6 +169,7 @@ mod blacklisted_name;
 mod blocks_in_if_conditions;
 mod booleans;
 mod bytecount;
+mod capitalized_acronyms;
 mod cargo_common_metadata;
 mod case_sensitive_file_extension_comparisons;
 mod checked_conversions;
@@ -559,6 +560,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &booleans::LOGIC_BUG,
         &booleans::NONMINIMAL_BOOL,
         &bytecount::NAIVE_BYTECOUNT,
+        &capitalized_acronyms::CAPITALIZED_ACRONYMS,
         &cargo_common_metadata::CARGO_COMMON_METADATA,
         &case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
         &checked_conversions::CHECKED_CONVERSIONS,
diff --git a/tests/ui/capitalized_acronyms.rs b/tests/ui/capitalized_acronyms.rs
new file mode 100644
index 0000000000000..bf5ab9f8bb7dd
--- /dev/null
+++ b/tests/ui/capitalized_acronyms.rs
@@ -0,0 +1,5 @@
+#![warn(clippy::capitalized_acronyms)]
+
+fn main() {
+    // test code goes here
+}

From ab1da8f86569e55d4b33702c6a062551f8abdd6e Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Sat, 19 Dec 2020 22:50:45 +0900
Subject: [PATCH 048/108] Add new lint `upper_case_acronyms`

---
 CHANGELOG.md                               |  2 +-
 clippy_lints/src/capitalized_acronyms.rs   | 28 -------
 clippy_lints/src/cognitive_complexity.rs   |  8 +-
 clippy_lints/src/int_plus_one.rs           | 24 +++---
 clippy_lints/src/lib.rs                    | 10 ++-
 clippy_lints/src/serde_api.rs              |  4 +-
 clippy_lints/src/upper_case_acronyms.rs    | 93 ++++++++++++++++++++++
 tests/ui/capitalized_acronyms.rs           |  5 --
 tests/ui/complex_types.rs                  |  2 +-
 tests/ui/complex_types.stderr              |  2 +-
 tests/ui/crashes/ice-6256.rs               |  1 +
 tests/ui/crashes/ice-6256.stderr           |  6 +-
 tests/ui/enum_variants.rs                  |  2 +-
 tests/ui/needless_question_mark.fixed      |  8 +-
 tests/ui/needless_question_mark.rs         |  8 +-
 tests/ui/needless_question_mark.stderr     | 28 +++----
 tests/ui/suspicious_operation_groupings.rs |  8 +-
 tests/ui/transmute_ptr_to_ptr.rs           |  6 +-
 tests/ui/unnested_or_patterns.fixed        |  2 +-
 tests/ui/unnested_or_patterns.rs           |  2 +-
 tests/ui/upper_case_acronyms.rs            | 21 +++++
 tests/ui/upper_case_acronyms.stderr        | 70 ++++++++++++++++
 tests/ui/use_self.fixed                    |  2 +-
 tests/ui/use_self.rs                       |  2 +-
 24 files changed, 256 insertions(+), 88 deletions(-)
 delete mode 100644 clippy_lints/src/capitalized_acronyms.rs
 create mode 100644 clippy_lints/src/upper_case_acronyms.rs
 delete mode 100644 tests/ui/capitalized_acronyms.rs
 create mode 100644 tests/ui/upper_case_acronyms.rs
 create mode 100644 tests/ui/upper_case_acronyms.stderr

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 963c9e77a18bc..04f042b2debf2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1877,7 +1877,6 @@ Released 2018-09-13
 [`box_vec`]: https://rust-lang.github.io/rust-clippy/master/index.html#box_vec
 [`boxed_local`]: https://rust-lang.github.io/rust-clippy/master/index.html#boxed_local
 [`builtin_type_shadow`]: https://rust-lang.github.io/rust-clippy/master/index.html#builtin_type_shadow
-[`capitalized_acronyms`]: https://rust-lang.github.io/rust-clippy/master/index.html#capitalized_acronyms
 [`cargo_common_metadata`]: https://rust-lang.github.io/rust-clippy/master/index.html#cargo_common_metadata
 [`case_sensitive_file_extension_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#case_sensitive_file_extension_comparisons
 [`cast_lossless`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
@@ -2275,6 +2274,7 @@ Released 2018-09-13
 [`unusual_byte_groupings`]: https://rust-lang.github.io/rust-clippy/master/index.html#unusual_byte_groupings
 [`unwrap_in_result`]: https://rust-lang.github.io/rust-clippy/master/index.html#unwrap_in_result
 [`unwrap_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#unwrap_used
+[`upper_case_acronyms`]: https://rust-lang.github.io/rust-clippy/master/index.html#upper_case_acronyms
 [`use_debug`]: https://rust-lang.github.io/rust-clippy/master/index.html#use_debug
 [`use_self`]: https://rust-lang.github.io/rust-clippy/master/index.html#use_self
 [`used_underscore_binding`]: https://rust-lang.github.io/rust-clippy/master/index.html#used_underscore_binding
diff --git a/clippy_lints/src/capitalized_acronyms.rs b/clippy_lints/src/capitalized_acronyms.rs
deleted file mode 100644
index 835e92dc04bce..0000000000000
--- a/clippy_lints/src/capitalized_acronyms.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-use rustc_lint::{EarlyLintPass, EarlyContext};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_ast::ast::*;
-
-declare_clippy_lint! {
-    /// **What it does:**
-    ///
-    /// **Why is this bad?**
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
-    /// ```rust
-    /// // example code where clippy issues a warning
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// // example code which does not raise clippy warning
-    /// ```
-    pub CAPITALIZED_ACRONYMS,
-    style,
-    "default lint description"
-}
-
-declare_lint_pass!(CapitalizedAcronyms => [CAPITALIZED_ACRONYMS]);
-
-impl EarlyLintPass for CapitalizedAcronyms {}
diff --git a/clippy_lints/src/cognitive_complexity.rs b/clippy_lints/src/cognitive_complexity.rs
index b3ebdf4ca30d8..f21a734bb439f 100644
--- a/clippy_lints/src/cognitive_complexity.rs
+++ b/clippy_lints/src/cognitive_complexity.rs
@@ -57,9 +57,9 @@ impl CognitiveComplexity {
 
         let expr = &body.value;
 
-        let mut helper = CCHelper { cc: 1, returns: 0 };
+        let mut helper = CcHelper { cc: 1, returns: 0 };
         helper.visit_expr(expr);
-        let CCHelper { cc, returns } = helper;
+        let CcHelper { cc, returns } = helper;
         let ret_ty = cx.typeck_results().node_type(expr.hir_id);
         let ret_adjust = if is_type_diagnostic_item(cx, ret_ty, sym::result_type) {
             returns
@@ -136,12 +136,12 @@ impl<'tcx> LateLintPass<'tcx> for CognitiveComplexity {
     }
 }
 
-struct CCHelper {
+struct CcHelper {
     cc: u64,
     returns: u64,
 }
 
-impl<'tcx> Visitor<'tcx> for CCHelper {
+impl<'tcx> Visitor<'tcx> for CcHelper {
     type Map = Map<'tcx>;
 
     fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
diff --git a/clippy_lints/src/int_plus_one.rs b/clippy_lints/src/int_plus_one.rs
index c629ee05ab97c..260b8988d3711 100644
--- a/clippy_lints/src/int_plus_one.rs
+++ b/clippy_lints/src/int_plus_one.rs
@@ -46,8 +46,8 @@ declare_lint_pass!(IntPlusOne => [INT_PLUS_ONE]);
 
 #[derive(Copy, Clone)]
 enum Side {
-    LHS,
-    RHS,
+    Lhs,
+    Rhs,
 }
 
 impl IntPlusOne {
@@ -66,11 +66,11 @@ impl IntPlusOne {
                 match (lhskind.node, &lhslhs.kind, &lhsrhs.kind) {
                     // `-1 + x`
                     (BinOpKind::Add, &ExprKind::Lit(ref lit), _) if Self::check_lit(lit, -1) => {
-                        Self::generate_recommendation(cx, binop, lhsrhs, rhs, Side::LHS)
+                        Self::generate_recommendation(cx, binop, lhsrhs, rhs, Side::Lhs)
                     },
                     // `x - 1`
                     (BinOpKind::Sub, _, &ExprKind::Lit(ref lit)) if Self::check_lit(lit, 1) => {
-                        Self::generate_recommendation(cx, binop, lhslhs, rhs, Side::LHS)
+                        Self::generate_recommendation(cx, binop, lhslhs, rhs, Side::Lhs)
                     },
                     _ => None,
                 }
@@ -82,10 +82,10 @@ impl IntPlusOne {
                 match (&rhslhs.kind, &rhsrhs.kind) {
                     // `y + 1` and `1 + y`
                     (&ExprKind::Lit(ref lit), _) if Self::check_lit(lit, 1) => {
-                        Self::generate_recommendation(cx, binop, rhsrhs, lhs, Side::RHS)
+                        Self::generate_recommendation(cx, binop, rhsrhs, lhs, Side::Rhs)
                     },
                     (_, &ExprKind::Lit(ref lit)) if Self::check_lit(lit, 1) => {
-                        Self::generate_recommendation(cx, binop, rhslhs, lhs, Side::RHS)
+                        Self::generate_recommendation(cx, binop, rhslhs, lhs, Side::Rhs)
                     },
                     _ => None,
                 }
@@ -97,10 +97,10 @@ impl IntPlusOne {
                 match (&lhslhs.kind, &lhsrhs.kind) {
                     // `1 + x` and `x + 1`
                     (&ExprKind::Lit(ref lit), _) if Self::check_lit(lit, 1) => {
-                        Self::generate_recommendation(cx, binop, lhsrhs, rhs, Side::LHS)
+                        Self::generate_recommendation(cx, binop, lhsrhs, rhs, Side::Lhs)
                     },
                     (_, &ExprKind::Lit(ref lit)) if Self::check_lit(lit, 1) => {
-                        Self::generate_recommendation(cx, binop, lhslhs, rhs, Side::LHS)
+                        Self::generate_recommendation(cx, binop, lhslhs, rhs, Side::Lhs)
                     },
                     _ => None,
                 }
@@ -110,11 +110,11 @@ impl IntPlusOne {
                 match (rhskind.node, &rhslhs.kind, &rhsrhs.kind) {
                     // `-1 + y`
                     (BinOpKind::Add, &ExprKind::Lit(ref lit), _) if Self::check_lit(lit, -1) => {
-                        Self::generate_recommendation(cx, binop, rhsrhs, lhs, Side::RHS)
+                        Self::generate_recommendation(cx, binop, rhsrhs, lhs, Side::Rhs)
                     },
                     // `y - 1`
                     (BinOpKind::Sub, _, &ExprKind::Lit(ref lit)) if Self::check_lit(lit, 1) => {
-                        Self::generate_recommendation(cx, binop, rhslhs, lhs, Side::RHS)
+                        Self::generate_recommendation(cx, binop, rhslhs, lhs, Side::Rhs)
                     },
                     _ => None,
                 }
@@ -138,8 +138,8 @@ impl IntPlusOne {
         if let Some(snippet) = snippet_opt(cx, node.span) {
             if let Some(other_side_snippet) = snippet_opt(cx, other_side.span) {
                 let rec = match side {
-                    Side::LHS => Some(format!("{} {} {}", snippet, binop_string, other_side_snippet)),
-                    Side::RHS => Some(format!("{} {} {}", other_side_snippet, binop_string, snippet)),
+                    Side::Lhs => Some(format!("{} {} {}", snippet, binop_string, other_side_snippet)),
+                    Side::Rhs => Some(format!("{} {} {}", other_side_snippet, binop_string, snippet)),
                 };
                 return rec;
             }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index a236e1b54bbc9..9b73c2496430b 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -6,6 +6,7 @@
 #![feature(concat_idents)]
 #![feature(crate_visibility_modifier)]
 #![feature(drain_filter)]
+#![feature(split_inclusive)]
 #![feature(in_band_lifetimes)]
 #![feature(once_cell)]
 #![feature(or_patterns)]
@@ -169,7 +170,6 @@ mod blacklisted_name;
 mod blocks_in_if_conditions;
 mod booleans;
 mod bytecount;
-mod capitalized_acronyms;
 mod cargo_common_metadata;
 mod case_sensitive_file_extension_comparisons;
 mod checked_conversions;
@@ -342,6 +342,7 @@ mod unused_self;
 mod unused_unit;
 mod unwrap;
 mod unwrap_in_result;
+mod upper_case_acronyms;
 mod use_self;
 mod useless_conversion;
 mod vec;
@@ -560,7 +561,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &booleans::LOGIC_BUG,
         &booleans::NONMINIMAL_BOOL,
         &bytecount::NAIVE_BYTECOUNT,
-        &capitalized_acronyms::CAPITALIZED_ACRONYMS,
         &cargo_common_metadata::CARGO_COMMON_METADATA,
         &case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
         &checked_conversions::CHECKED_CONVERSIONS,
@@ -946,6 +946,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &unwrap::PANICKING_UNWRAP,
         &unwrap::UNNECESSARY_UNWRAP,
         &unwrap_in_result::UNWRAP_IN_RESULT,
+        &upper_case_acronyms::UPPER_CASE_ACRONYMS,
         &use_self::USE_SELF,
         &useless_conversion::USELESS_CONVERSION,
         &vec::USELESS_VEC,
@@ -985,7 +986,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     }
     store.register_late_pass(|| box utils::author::Author);
     store.register_late_pass(|| box await_holding_invalid::AwaitHolding);
-    store.register_late_pass(|| box serde_api::SerdeAPI);
+    store.register_late_pass(|| box serde_api::SerdeApi);
     let vec_box_size_threshold = conf.vec_box_size_threshold;
     store.register_late_pass(move || box types::Types::new(vec_box_size_threshold));
     store.register_late_pass(|| box booleans::NonminimalBool);
@@ -1176,6 +1177,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let enum_variant_name_threshold = conf.enum_variant_name_threshold;
     store.register_early_pass(move || box enum_variants::EnumVariantNames::new(enum_variant_name_threshold));
     store.register_early_pass(|| box tabs_in_doc_comments::TabsInDocComments);
+    store.register_early_pass(|| box upper_case_acronyms::UpperCaseAcronyms);
     store.register_late_pass(|| box default::Default::default());
     store.register_late_pass(|| box unused_self::UnusedSelf);
     store.register_late_pass(|| box mutable_debug_assertion::DebugAssertWithMutCall);
@@ -1661,6 +1663,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&unused_unit::UNUSED_UNIT),
         LintId::of(&unwrap::PANICKING_UNWRAP),
         LintId::of(&unwrap::UNNECESSARY_UNWRAP),
+        LintId::of(&upper_case_acronyms::UPPER_CASE_ACRONYMS),
         LintId::of(&useless_conversion::USELESS_CONVERSION),
         LintId::of(&vec::USELESS_VEC),
         LintId::of(&vec_init_then_push::VEC_INIT_THEN_PUSH),
@@ -1778,6 +1781,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&types::FN_TO_NUMERIC_CAST_WITH_TRUNCATION),
         LintId::of(&unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
         LintId::of(&unused_unit::UNUSED_UNIT),
+        LintId::of(&upper_case_acronyms::UPPER_CASE_ACRONYMS),
         LintId::of(&write::PRINTLN_EMPTY_STRING),
         LintId::of(&write::PRINT_LITERAL),
         LintId::of(&write::PRINT_WITH_NEWLINE),
diff --git a/clippy_lints/src/serde_api.rs b/clippy_lints/src/serde_api.rs
index 44e739725c820..90cf1b6c86135 100644
--- a/clippy_lints/src/serde_api.rs
+++ b/clippy_lints/src/serde_api.rs
@@ -18,9 +18,9 @@ declare_clippy_lint! {
     "various things that will negatively affect your serde experience"
 }
 
-declare_lint_pass!(SerdeAPI => [SERDE_API_MISUSE]);
+declare_lint_pass!(SerdeApi => [SERDE_API_MISUSE]);
 
-impl<'tcx> LateLintPass<'tcx> for SerdeAPI {
+impl<'tcx> LateLintPass<'tcx> for SerdeApi {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         if let ItemKind::Impl(Impl {
             of_trait: Some(ref trait_ref),
diff --git a/clippy_lints/src/upper_case_acronyms.rs b/clippy_lints/src/upper_case_acronyms.rs
new file mode 100644
index 0000000000000..61e7031716a9d
--- /dev/null
+++ b/clippy_lints/src/upper_case_acronyms.rs
@@ -0,0 +1,93 @@
+use crate::utils::span_lint_and_sugg;
+use if_chain::if_chain;
+use itertools::Itertools;
+use rustc_ast::ast::{Item, ItemKind, Variant};
+use rustc_errors::Applicability;
+use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::Ident;
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for camel case name containing a capitalized acronym.
+    ///
+    /// **Why is this bad?** In CamelCase, acronyms count as one word.
+    /// See [naming conventions](https://rust-lang.github.io/api-guidelines/naming.html#casing-conforms-to-rfc-430-c-case)
+    /// for more.
+    ///
+    /// **Known problems:** When two acronyms are contiguous, the lint can't tell where
+    /// the first acronym ends and the second starts, so it suggests to lowercase all of
+    /// the letters in the second acronym.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// struct HTTPResponse;
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// struct HttpResponse;
+    /// ```
+    pub UPPER_CASE_ACRONYMS,
+    style,
+    "capitalized acronyms are against the naming convention"
+}
+
+declare_lint_pass!(UpperCaseAcronyms => [UPPER_CASE_ACRONYMS]);
+
+fn correct_ident(ident: &str) -> String {
+    let ident = ident.chars().rev().collect::<String>();
+    let fragments = ident
+        .split_inclusive(|x: char| !x.is_ascii_lowercase())
+        .rev()
+        .map(|x| x.chars().rev().collect::<String>());
+
+    let mut ident = fragments.clone().next().unwrap();
+    for (ref prev, ref curr) in fragments.tuple_windows() {
+        if [prev, curr]
+            .iter()
+            .all(|s| s.len() == 1 && s.chars().next().unwrap().is_ascii_uppercase())
+        {
+            ident.push_str(&curr.to_ascii_lowercase());
+        } else {
+            ident.push_str(curr);
+        }
+    }
+    ident
+}
+
+fn check_ident(cx: &EarlyContext<'_>, ident: &Ident) {
+    let span = ident.span;
+    let ident = &ident.as_str();
+    let corrected = correct_ident(ident);
+    if ident != &corrected {
+        span_lint_and_sugg(
+            cx,
+            UPPER_CASE_ACRONYMS,
+            span,
+            &format!("name `{}` contains a capitalized acronym", ident),
+            "consider making the acronym lowercase, except the initial letter",
+            corrected,
+            Applicability::MaybeIncorrect,
+        )
+    }
+}
+
+impl EarlyLintPass for UpperCaseAcronyms {
+    fn check_item(&mut self, cx: &EarlyContext<'_>, it: &Item) {
+        if_chain! {
+            if !in_external_macro(cx.sess(), it.span);
+            if matches!(
+                it.kind,
+                ItemKind::TyAlias(..) | ItemKind::Enum(..) | ItemKind::Struct(..) | ItemKind::Trait(..)
+            );
+            then {
+                check_ident(cx, &it.ident);
+            }
+        }
+    }
+
+    fn check_variant(&mut self, cx: &EarlyContext<'_>, v: &Variant) {
+        check_ident(cx, &v.ident);
+    }
+}
diff --git a/tests/ui/capitalized_acronyms.rs b/tests/ui/capitalized_acronyms.rs
deleted file mode 100644
index bf5ab9f8bb7dd..0000000000000
--- a/tests/ui/capitalized_acronyms.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-#![warn(clippy::capitalized_acronyms)]
-
-fn main() {
-    // test code goes here
-}
diff --git a/tests/ui/complex_types.rs b/tests/ui/complex_types.rs
index be61fb6b9be61..383bbb49dbe88 100644
--- a/tests/ui/complex_types.rs
+++ b/tests/ui/complex_types.rs
@@ -11,7 +11,7 @@ struct S {
     f: Vec<Vec<Box<(u32, u32, u32, u32)>>>,
 }
 
-struct TS(Vec<Vec<Box<(u32, u32, u32, u32)>>>);
+struct Ts(Vec<Vec<Box<(u32, u32, u32, u32)>>>);
 
 enum E {
     Tuple(Vec<Vec<Box<(u32, u32, u32, u32)>>>),
diff --git a/tests/ui/complex_types.stderr b/tests/ui/complex_types.stderr
index 8f5dbd27956c5..7fcbb4bce8836 100644
--- a/tests/ui/complex_types.stderr
+++ b/tests/ui/complex_types.stderr
@@ -21,7 +21,7 @@ LL |     f: Vec<Vec<Box<(u32, u32, u32, u32)>>>,
 error: very complex type used. Consider factoring parts into `type` definitions
   --> $DIR/complex_types.rs:14:11
    |
-LL | struct TS(Vec<Vec<Box<(u32, u32, u32, u32)>>>);
+LL | struct Ts(Vec<Vec<Box<(u32, u32, u32, u32)>>>);
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: very complex type used. Consider factoring parts into `type` definitions
diff --git a/tests/ui/crashes/ice-6256.rs b/tests/ui/crashes/ice-6256.rs
index 6f60d45d68a8e..5409f36b3f1ed 100644
--- a/tests/ui/crashes/ice-6256.rs
+++ b/tests/ui/crashes/ice-6256.rs
@@ -1,5 +1,6 @@
 // originally from rustc ./src/test/ui/regions/issue-78262.rs
 // ICE: to get the signature of a closure, use substs.as_closure().sig() not fn_sig()
+#![allow(clippy::upper_case_acronyms)]
 
 trait TT {}
 
diff --git a/tests/ui/crashes/ice-6256.stderr b/tests/ui/crashes/ice-6256.stderr
index 0e8353a418a87..d1a8bdc3c8d8c 100644
--- a/tests/ui/crashes/ice-6256.stderr
+++ b/tests/ui/crashes/ice-6256.stderr
@@ -1,13 +1,13 @@
 error[E0308]: mismatched types
-  --> $DIR/ice-6256.rs:11:28
+  --> $DIR/ice-6256.rs:12:28
    |
 LL |     let f = |x: &dyn TT| x.func(); //[default]~ ERROR: mismatched types
    |                            ^^^^ lifetime mismatch
    |
    = note: expected reference `&(dyn TT + 'static)`
               found reference `&dyn TT`
-note: the anonymous lifetime #1 defined on the body at 11:13...
-  --> $DIR/ice-6256.rs:11:13
+note: the anonymous lifetime #1 defined on the body at 12:13...
+  --> $DIR/ice-6256.rs:12:13
    |
 LL |     let f = |x: &dyn TT| x.func(); //[default]~ ERROR: mismatched types
    |             ^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/enum_variants.rs b/tests/ui/enum_variants.rs
index 01774a2a9845c..89d99dcf0c867 100644
--- a/tests/ui/enum_variants.rs
+++ b/tests/ui/enum_variants.rs
@@ -1,6 +1,6 @@
 #![feature(non_ascii_idents)]
 #![warn(clippy::enum_variant_names, clippy::pub_enum_variant_names)]
-#![allow(non_camel_case_types)]
+#![allow(non_camel_case_types, clippy::upper_case_acronyms)]
 
 enum FakeCallType {
     CALL,
diff --git a/tests/ui/needless_question_mark.fixed b/tests/ui/needless_question_mark.fixed
index 70218f3f041d8..71fb3565224e4 100644
--- a/tests/ui/needless_question_mark.fixed
+++ b/tests/ui/needless_question_mark.fixed
@@ -1,7 +1,13 @@
 // run-rustfix
 
 #![warn(clippy::needless_question_mark)]
-#![allow(clippy::needless_return, clippy::unnecessary_unwrap, dead_code, unused_must_use)]
+#![allow(
+    clippy::needless_return,
+    clippy::unnecessary_unwrap,
+    clippy::upper_case_acronyms,
+    dead_code,
+    unused_must_use
+)]
 #![feature(custom_inner_attributes)]
 
 struct TO {
diff --git a/tests/ui/needless_question_mark.rs b/tests/ui/needless_question_mark.rs
index 60ac2c8d72eac..e31f6f48fa7c7 100644
--- a/tests/ui/needless_question_mark.rs
+++ b/tests/ui/needless_question_mark.rs
@@ -1,7 +1,13 @@
 // run-rustfix
 
 #![warn(clippy::needless_question_mark)]
-#![allow(clippy::needless_return, clippy::unnecessary_unwrap, dead_code, unused_must_use)]
+#![allow(
+    clippy::needless_return,
+    clippy::unnecessary_unwrap,
+    clippy::upper_case_acronyms,
+    dead_code,
+    unused_must_use
+)]
 #![feature(custom_inner_attributes)]
 
 struct TO {
diff --git a/tests/ui/needless_question_mark.stderr b/tests/ui/needless_question_mark.stderr
index b4eb21882ece9..567bc518a3fda 100644
--- a/tests/ui/needless_question_mark.stderr
+++ b/tests/ui/needless_question_mark.stderr
@@ -1,5 +1,5 @@
 error: Question mark operator is useless here
-  --> $DIR/needless_question_mark.rs:17:12
+  --> $DIR/needless_question_mark.rs:23:12
    |
 LL |     return Some(to.magic?);
    |            ^^^^^^^^^^^^^^^ help: try: `to.magic`
@@ -7,79 +7,79 @@ LL |     return Some(to.magic?);
    = note: `-D clippy::needless-question-mark` implied by `-D warnings`
 
 error: Question mark operator is useless here
-  --> $DIR/needless_question_mark.rs:25:12
+  --> $DIR/needless_question_mark.rs:31:12
    |
 LL |     return Some(to.magic?)
    |            ^^^^^^^^^^^^^^^ help: try: `to.magic`
 
 error: Question mark operator is useless here
-  --> $DIR/needless_question_mark.rs:30:5
+  --> $DIR/needless_question_mark.rs:36:5
    |
 LL |     Some(to.magic?)
    |     ^^^^^^^^^^^^^^^ help: try: `to.magic`
 
 error: Question mark operator is useless here
-  --> $DIR/needless_question_mark.rs:35:21
+  --> $DIR/needless_question_mark.rs:41:21
    |
 LL |     to.and_then(|t| Some(t.magic?))
    |                     ^^^^^^^^^^^^^^ help: try: `t.magic`
 
 error: Question mark operator is useless here
-  --> $DIR/needless_question_mark.rs:44:9
+  --> $DIR/needless_question_mark.rs:50:9
    |
 LL |         Some(t.magic?)
    |         ^^^^^^^^^^^^^^ help: try: `t.magic`
 
 error: Question mark operator is useless here
-  --> $DIR/needless_question_mark.rs:49:12
+  --> $DIR/needless_question_mark.rs:55:12
    |
 LL |     return Ok(tr.magic?);
    |            ^^^^^^^^^^^^^ help: try: `tr.magic`
 
 error: Question mark operator is useless here
-  --> $DIR/needless_question_mark.rs:56:12
+  --> $DIR/needless_question_mark.rs:62:12
    |
 LL |     return Ok(tr.magic?)
    |            ^^^^^^^^^^^^^ help: try: `tr.magic`
 
 error: Question mark operator is useless here
-  --> $DIR/needless_question_mark.rs:60:5
+  --> $DIR/needless_question_mark.rs:66:5
    |
 LL |     Ok(tr.magic?)
    |     ^^^^^^^^^^^^^ help: try: `tr.magic`
 
 error: Question mark operator is useless here
-  --> $DIR/needless_question_mark.rs:64:21
+  --> $DIR/needless_question_mark.rs:70:21
    |
 LL |     tr.and_then(|t| Ok(t.magic?))
    |                     ^^^^^^^^^^^^ help: try: `t.magic`
 
 error: Question mark operator is useless here
-  --> $DIR/needless_question_mark.rs:72:9
+  --> $DIR/needless_question_mark.rs:78:9
    |
 LL |         Ok(t.magic?)
    |         ^^^^^^^^^^^^ help: try: `t.magic`
 
 error: Question mark operator is useless here
-  --> $DIR/needless_question_mark.rs:79:16
+  --> $DIR/needless_question_mark.rs:85:16
    |
 LL |         return Ok(t.magic?);
    |                ^^^^^^^^^^^^ help: try: `t.magic`
 
 error: Question mark operator is useless here
-  --> $DIR/needless_question_mark.rs:132:9
+  --> $DIR/needless_question_mark.rs:138:9
    |
 LL |         Ok(to.magic?) // should be triggered
    |         ^^^^^^^^^^^^^ help: try: `to.magic`
 
 error: Question mark operator is useless here
-  --> $DIR/needless_question_mark.rs:148:9
+  --> $DIR/needless_question_mark.rs:154:9
    |
 LL |         Some(to.magic?) // should be triggered
    |         ^^^^^^^^^^^^^^^ help: try: `to.magic`
 
 error: Question mark operator is useless here
-  --> $DIR/needless_question_mark.rs:156:9
+  --> $DIR/needless_question_mark.rs:162:9
    |
 LL |         Ok(to.magic?) // should be triggered
    |         ^^^^^^^^^^^^^ help: try: `to.magic`
diff --git a/tests/ui/suspicious_operation_groupings.rs b/tests/ui/suspicious_operation_groupings.rs
index dd6f4ec7bd9b5..2f8c7cec50f8e 100644
--- a/tests/ui/suspicious_operation_groupings.rs
+++ b/tests/ui/suspicious_operation_groupings.rs
@@ -27,7 +27,7 @@ fn buggy_ab_cmp(s1: &S, s2: &S) -> bool {
     s1.a < s2.a && s1.a < s2.b
 }
 
-struct SAOnly {
+struct SaOnly {
     a: i32,
 }
 
@@ -37,13 +37,13 @@ impl S {
     }
 }
 
-fn do_not_give_bad_suggestions_for_this_unusual_expr(s1: &S, s2: &SAOnly) -> bool {
+fn do_not_give_bad_suggestions_for_this_unusual_expr(s1: &S, s2: &SaOnly) -> bool {
     // This is superficially similar to `buggy_ab_cmp`, but we should not suggest
     // `s2.b` since that is invalid.
     s1.a < s2.a && s1.a() < s1.b
 }
 
-fn do_not_give_bad_suggestions_for_this_macro_expr(s1: &S, s2: &SAOnly) -> bool {
+fn do_not_give_bad_suggestions_for_this_macro_expr(s1: &S, s2: &SaOnly) -> bool {
     macro_rules! s1 {
         () => {
             S {
@@ -60,7 +60,7 @@ fn do_not_give_bad_suggestions_for_this_macro_expr(s1: &S, s2: &SAOnly) -> bool
     s1.a < s2.a && s1!().a < s1.b
 }
 
-fn do_not_give_bad_suggestions_for_this_incorrect_expr(s1: &S, s2: &SAOnly) -> bool {
+fn do_not_give_bad_suggestions_for_this_incorrect_expr(s1: &S, s2: &SaOnly) -> bool {
     // There's two `s1.b`, but we should not suggest `s2.b` since that is invalid
     s1.a < s2.a && s1.b < s1.b
 }
diff --git a/tests/ui/transmute_ptr_to_ptr.rs b/tests/ui/transmute_ptr_to_ptr.rs
index 26b03bdc74055..9e213aab68c57 100644
--- a/tests/ui/transmute_ptr_to_ptr.rs
+++ b/tests/ui/transmute_ptr_to_ptr.rs
@@ -53,10 +53,10 @@ fn transmute_ptr_to_ptr() {
 
 // dereferencing raw pointers in const contexts, should not lint as it's unstable (issue 5959)
 const _: &() = {
-    struct ZST;
-    let zst = &ZST;
+    struct Zst;
+    let zst = &Zst;
 
-    unsafe { std::mem::transmute::<&'static ZST, &'static ()>(zst) }
+    unsafe { std::mem::transmute::<&'static Zst, &'static ()>(zst) }
 };
 
 fn main() {}
diff --git a/tests/ui/unnested_or_patterns.fixed b/tests/ui/unnested_or_patterns.fixed
index b39e891094fd9..13a036cd800bc 100644
--- a/tests/ui/unnested_or_patterns.fixed
+++ b/tests/ui/unnested_or_patterns.fixed
@@ -3,7 +3,7 @@
 #![feature(or_patterns)]
 #![feature(box_patterns)]
 #![warn(clippy::unnested_or_patterns)]
-#![allow(clippy::cognitive_complexity, clippy::match_ref_pats)]
+#![allow(clippy::cognitive_complexity, clippy::match_ref_pats, clippy::upper_case_acronyms)]
 #![allow(unreachable_patterns, irrefutable_let_patterns, unused_variables)]
 
 fn main() {
diff --git a/tests/ui/unnested_or_patterns.rs b/tests/ui/unnested_or_patterns.rs
index 096f5a71150b8..4a10cc702c401 100644
--- a/tests/ui/unnested_or_patterns.rs
+++ b/tests/ui/unnested_or_patterns.rs
@@ -3,7 +3,7 @@
 #![feature(or_patterns)]
 #![feature(box_patterns)]
 #![warn(clippy::unnested_or_patterns)]
-#![allow(clippy::cognitive_complexity, clippy::match_ref_pats)]
+#![allow(clippy::cognitive_complexity, clippy::match_ref_pats, clippy::upper_case_acronyms)]
 #![allow(unreachable_patterns, irrefutable_let_patterns, unused_variables)]
 
 fn main() {
diff --git a/tests/ui/upper_case_acronyms.rs b/tests/ui/upper_case_acronyms.rs
new file mode 100644
index 0000000000000..af0b577634863
--- /dev/null
+++ b/tests/ui/upper_case_acronyms.rs
@@ -0,0 +1,21 @@
+#![warn(clippy::upper_case_acronyms)]
+
+struct HTTPResponse; // linted
+
+struct CString; // not linted
+
+enum Flags {
+    NS, // linted
+    CWR,
+    ECE,
+    URG,
+    ACK,
+    PSH,
+    RST,
+    SYN,
+    FIN,
+}
+
+struct GCCLLVMSomething; // linted, beware that lint suggests `GccllvmSomething` instead of `GccLlvmSomething`
+
+fn main() {}
diff --git a/tests/ui/upper_case_acronyms.stderr b/tests/ui/upper_case_acronyms.stderr
new file mode 100644
index 0000000000000..2065fe10bb151
--- /dev/null
+++ b/tests/ui/upper_case_acronyms.stderr
@@ -0,0 +1,70 @@
+error: name `HTTPResponse` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:3:8
+   |
+LL | struct HTTPResponse; // linted
+   |        ^^^^^^^^^^^^ help: consider making the acronym lowercase, except the initial letter: `HttpResponse`
+   |
+   = note: `-D clippy::upper-case-acronyms` implied by `-D warnings`
+
+error: name `NS` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:8:5
+   |
+LL |     NS, // linted
+   |     ^^ help: consider making the acronym lowercase, except the initial letter (notice the capitalization): `Ns`
+
+error: name `CWR` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:9:5
+   |
+LL |     CWR,
+   |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Cwr`
+
+error: name `ECE` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:10:5
+   |
+LL |     ECE,
+   |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Ece`
+
+error: name `URG` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:11:5
+   |
+LL |     URG,
+   |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Urg`
+
+error: name `ACK` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:12:5
+   |
+LL |     ACK,
+   |     ^^^ help: consider making the acronym lowercase, except the initial letter (notice the capitalization): `Ack`
+
+error: name `PSH` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:13:5
+   |
+LL |     PSH,
+   |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Psh`
+
+error: name `RST` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:14:5
+   |
+LL |     RST,
+   |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Rst`
+
+error: name `SYN` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:15:5
+   |
+LL |     SYN,
+   |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Syn`
+
+error: name `FIN` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:16:5
+   |
+LL |     FIN,
+   |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Fin`
+
+error: name `GCCLLVMSomething` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:19:8
+   |
+LL | struct GCCLLVMSomething; // linted, beware that lint suggests `GccllvmSomething` instead of `GccLlvmSomething`
+   |        ^^^^^^^^^^^^^^^^ help: consider making the acronym lowercase, except the initial letter: `GccllvmSomething`
+
+error: aborting due to 11 previous errors
+
diff --git a/tests/ui/use_self.fixed b/tests/ui/use_self.fixed
index d6a890014e681..bb2012441d90c 100644
--- a/tests/ui/use_self.fixed
+++ b/tests/ui/use_self.fixed
@@ -3,7 +3,7 @@
 
 #![warn(clippy::use_self)]
 #![allow(dead_code)]
-#![allow(clippy::should_implement_trait)]
+#![allow(clippy::should_implement_trait, clippy::upper_case_acronyms)]
 
 fn main() {}
 
diff --git a/tests/ui/use_self.rs b/tests/ui/use_self.rs
index b04d9ce75b2a5..ddfd2beba3107 100644
--- a/tests/ui/use_self.rs
+++ b/tests/ui/use_self.rs
@@ -3,7 +3,7 @@
 
 #![warn(clippy::use_self)]
 #![allow(dead_code)]
-#![allow(clippy::should_implement_trait)]
+#![allow(clippy::should_implement_trait, clippy::upper_case_acronyms)]
 
 fn main() {}
 

From 0ccb491caa668d55522c1bc78e368329a310db4c Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Wed, 20 Jan 2021 18:14:09 +0900
Subject: [PATCH 049/108] Remove nightly-gate of `split_inclusive`

Co-authored-by: Philipp Krones <hello@philkrones.com>
---
 clippy_lints/src/lib.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 9b73c2496430b..53764bb73903a 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -6,7 +6,6 @@
 #![feature(concat_idents)]
 #![feature(crate_visibility_modifier)]
 #![feature(drain_filter)]
-#![feature(split_inclusive)]
 #![feature(in_band_lifetimes)]
 #![feature(once_cell)]
 #![feature(or_patterns)]

From 2be935d396a650a1480859a75011a742df882c74 Mon Sep 17 00:00:00 2001
From: Aaron Hill <aa1ronham@gmail.com>
Date: Mon, 18 Jan 2021 16:47:37 -0500
Subject: [PATCH 050/108] Force token collection to run when parsing
 nonterminals

Fixes #81007

Previously, we would fail to collect tokens in the proper place when
only builtin attributes were present. As a result, we would end up with
attribute tokens in the collected `TokenStream`, leading to duplication
when we attempted to prepend the attributes from the AST node.

We now explicitly track when token collection must be performed due to
nomterminal parsing.
---
 clippy_lints/src/doc.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index f518da55cd76f..3a754f4991782 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -12,6 +12,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
 use rustc_parse::maybe_new_parser_from_source_str;
+use rustc_parse::parser::ForceCollect;
 use rustc_session::parse::ParseSess;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::edition::Edition;
@@ -483,7 +484,7 @@ fn check_code(cx: &LateContext<'_>, text: &str, edition: Edition, span: Span) {
 
                 let mut relevant_main_found = false;
                 loop {
-                    match parser.parse_item() {
+                    match parser.parse_item(ForceCollect::No) {
                         Ok(Some(item)) => match &item.kind {
                             // Tests with one of these items are ignored
                             ItemKind::Static(..)

From e42208f1b7befe316e32c66b6dc6d242a56f4d84 Mon Sep 17 00:00:00 2001
From: pastchick3 <331604390@qq.com>
Date: Wed, 20 Jan 2021 20:05:25 +0800
Subject: [PATCH 051/108] Improve the suggestion message of
 `stable_sort_primitive`.

---
 clippy_lints/src/stable_sort_primitive.rs | 31 ++++++++++++++---------
 tests/ui/stable_sort_primitive.stderr     | 27 +++++++++++++++-----
 2 files changed, 39 insertions(+), 19 deletions(-)

diff --git a/clippy_lints/src/stable_sort_primitive.rs b/clippy_lints/src/stable_sort_primitive.rs
index 99e4b293ac680..276a9338819d9 100644
--- a/clippy_lints/src/stable_sort_primitive.rs
+++ b/clippy_lints/src/stable_sort_primitive.rs
@@ -1,4 +1,4 @@
-use crate::utils::{is_slice_of_primitives, span_lint_and_sugg, sugg::Sugg};
+use crate::utils::{is_slice_of_primitives, span_lint_and_then, sugg::Sugg};
 
 use if_chain::if_chain;
 
@@ -107,25 +107,32 @@ fn detect_stable_sort_primitive(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option
 impl LateLintPass<'_> for StableSortPrimitive {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
         if let Some(detection) = detect_stable_sort_primitive(cx, expr) {
-            span_lint_and_sugg(
+            span_lint_and_then(
                 cx,
                 STABLE_SORT_PRIMITIVE,
                 expr.span,
                 format!(
-                    "used {} instead of {} to sort primitive type `{}`",
+                    "used `{}` on primitive type `{}`",
                     detection.method.stable_name(),
-                    detection.method.unstable_name(),
                     detection.slice_type,
                 )
                 .as_str(),
-                "try",
-                format!(
-                    "{}.{}({})",
-                    detection.slice_name,
-                    detection.method.unstable_name(),
-                    detection.method_args
-                ),
-                Applicability::MachineApplicable,
+                |diag| {
+                    diag.span_suggestion(
+                        expr.span,
+                        "try",
+                        format!(
+                            "{}.{}({})",
+                            detection.slice_name,
+                            detection.method.unstable_name(),
+                            detection.method_args,
+                        ),
+                        Applicability::MachineApplicable,
+                    );
+                    diag.note(
+                        "an unstable sort would perform faster without any observable difference for this data type",
+                    );
+                },
             );
         }
     }
diff --git a/tests/ui/stable_sort_primitive.stderr b/tests/ui/stable_sort_primitive.stderr
index 780389f32bc1c..b8d22ed250467 100644
--- a/tests/ui/stable_sort_primitive.stderr
+++ b/tests/ui/stable_sort_primitive.stderr
@@ -1,46 +1,59 @@
-error: used sort instead of sort_unstable to sort primitive type `i32`
+error: used `sort` on primitive type `i32`
   --> $DIR/stable_sort_primitive.rs:7:5
    |
 LL |     vec.sort();
    |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
    |
    = note: `-D clippy::stable-sort-primitive` implied by `-D warnings`
+   = note: an unstable sort would perform faster without any observable difference for this data type
 
-error: used sort instead of sort_unstable to sort primitive type `bool`
+error: used `sort` on primitive type `bool`
   --> $DIR/stable_sort_primitive.rs:9:5
    |
 LL |     vec.sort();
    |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
+   |
+   = note: an unstable sort would perform faster without any observable difference for this data type
 
-error: used sort instead of sort_unstable to sort primitive type `char`
+error: used `sort` on primitive type `char`
   --> $DIR/stable_sort_primitive.rs:11:5
    |
 LL |     vec.sort();
    |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
+   |
+   = note: an unstable sort would perform faster without any observable difference for this data type
 
-error: used sort instead of sort_unstable to sort primitive type `str`
+error: used `sort` on primitive type `str`
   --> $DIR/stable_sort_primitive.rs:13:5
    |
 LL |     vec.sort();
    |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
+   |
+   = note: an unstable sort would perform faster without any observable difference for this data type
 
-error: used sort instead of sort_unstable to sort primitive type `tuple`
+error: used `sort` on primitive type `tuple`
   --> $DIR/stable_sort_primitive.rs:15:5
    |
 LL |     vec.sort();
    |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
+   |
+   = note: an unstable sort would perform faster without any observable difference for this data type
 
-error: used sort instead of sort_unstable to sort primitive type `array`
+error: used `sort` on primitive type `array`
   --> $DIR/stable_sort_primitive.rs:17:5
    |
 LL |     vec.sort();
    |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
+   |
+   = note: an unstable sort would perform faster without any observable difference for this data type
 
-error: used sort instead of sort_unstable to sort primitive type `i32`
+error: used `sort` on primitive type `i32`
   --> $DIR/stable_sort_primitive.rs:19:5
    |
 LL |     arr.sort();
    |     ^^^^^^^^^^ help: try: `arr.sort_unstable()`
+   |
+   = note: an unstable sort would perform faster without any observable difference for this data type
 
 error: aborting due to 7 previous errors
 

From f1ab3024b27cc7c02a80fd54382a10a1b4ef3bcd Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Thu, 21 Jan 2021 12:48:30 -0800
Subject: [PATCH 052/108] New lint: exhaustive_enums

---
 CHANGELOG.md                         |  1 +
 clippy_lints/src/exhaustive_enums.rs | 68 ++++++++++++++++++++++++++++
 clippy_lints/src/lib.rs              |  4 ++
 tests/ui/exhaustive_enums.fixed      | 24 ++++++++++
 tests/ui/exhaustive_enums.rs         | 23 ++++++++++
 tests/ui/exhaustive_enums.stderr     | 28 ++++++++++++
 6 files changed, 148 insertions(+)
 create mode 100644 clippy_lints/src/exhaustive_enums.rs
 create mode 100644 tests/ui/exhaustive_enums.fixed
 create mode 100644 tests/ui/exhaustive_enums.rs
 create mode 100644 tests/ui/exhaustive_enums.stderr

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 04f042b2debf2..4cf2125ea2fc0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1938,6 +1938,7 @@ Released 2018-09-13
 [`erasing_op`]: https://rust-lang.github.io/rust-clippy/master/index.html#erasing_op
 [`eval_order_dependence`]: https://rust-lang.github.io/rust-clippy/master/index.html#eval_order_dependence
 [`excessive_precision`]: https://rust-lang.github.io/rust-clippy/master/index.html#excessive_precision
+[`exhaustive_enums`]: https://rust-lang.github.io/rust-clippy/master/index.html#exhaustive_enums
 [`exit`]: https://rust-lang.github.io/rust-clippy/master/index.html#exit
 [`expect_fun_call`]: https://rust-lang.github.io/rust-clippy/master/index.html#expect_fun_call
 [`expect_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#expect_used
diff --git a/clippy_lints/src/exhaustive_enums.rs b/clippy_lints/src/exhaustive_enums.rs
new file mode 100644
index 0000000000000..099171962d3c9
--- /dev/null
+++ b/clippy_lints/src/exhaustive_enums.rs
@@ -0,0 +1,68 @@
+use crate::utils::{snippet_opt, span_lint_and_help, span_lint_and_sugg};
+use if_chain::if_chain;
+use rustc_ast::ast::{Item, ItemKind};
+use rustc_errors::Applicability;
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
+
+declare_clippy_lint! {
+    /// **What it does:** Warns on any `enum`s that are not tagged `#[non_exhaustive]`
+    ///
+    /// **Why is this bad?** Exhaustive enums are typically fine, but a project which does
+    /// not wish to make a stability commitment around enums may wish to disable them by default.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// enum Foo {
+    ///     Bar,
+    ///     Baz
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// #[non_exhaustive]
+    /// enum Foo {
+    ///     Bar,
+    ///     Baz
+    /// }    /// ```
+    pub EXHAUSTIVE_ENUMS,
+    restriction,
+    "default lint description"
+}
+
+declare_lint_pass!(ExhaustiveEnums => [EXHAUSTIVE_ENUMS]);
+
+impl EarlyLintPass for ExhaustiveEnums {
+    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
+        if_chain! {
+            if let ItemKind::Enum(..) = item.kind;
+            if !item.attrs.iter().any(|a| a.has_name(sym::non_exhaustive));
+            then {
+                if let Some(snippet) = snippet_opt(cx, item.span) {
+                    span_lint_and_sugg(
+                        cx,
+                        EXHAUSTIVE_ENUMS,
+                        item.span,
+                        "enums should not be exhaustive",
+                        "try adding #[non_exhaustive]",
+                        format!("#[non_exhaustive]\n{}", snippet),
+                        Applicability::MaybeIncorrect,
+                    );
+                } else {
+                    span_lint_and_help(
+                        cx,
+                        EXHAUSTIVE_ENUMS,
+                        item.span,
+                        "enums should not be exhaustive",
+                        None,
+                        "try adding #[non_exhaustive]",
+                    );
+                }
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 53764bb73903a..465ad3846cecf 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -200,6 +200,7 @@ mod escape;
 mod eta_reduction;
 mod eval_order_dependence;
 mod excessive_bools;
+mod exhaustive_enums;
 mod exit;
 mod explicit_write;
 mod fallible_impl_from;
@@ -611,6 +612,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &eval_order_dependence::EVAL_ORDER_DEPENDENCE,
         &excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS,
         &excessive_bools::STRUCT_EXCESSIVE_BOOLS,
+        &exhaustive_enums::EXHAUSTIVE_ENUMS,
         &exit::EXIT,
         &explicit_write::EXPLICIT_WRITE,
         &fallible_impl_from::FALLIBLE_IMPL_FROM,
@@ -1096,6 +1098,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box eval_order_dependence::EvalOrderDependence);
     store.register_late_pass(|| box missing_doc::MissingDoc::new());
     store.register_late_pass(|| box missing_inline::MissingInline);
+    store.register_early_pass(move || box exhaustive_enums::ExhaustiveEnums);
     store.register_late_pass(|| box if_let_some_result::OkIfLet);
     store.register_late_pass(|| box partialeq_ne_impl::PartialEqNeImpl);
     store.register_late_pass(|| box unused_io_amount::UnusedIoAmount);
@@ -1246,6 +1249,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&create_dir::CREATE_DIR),
         LintId::of(&dbg_macro::DBG_MACRO),
         LintId::of(&else_if_without_else::ELSE_IF_WITHOUT_ELSE),
+        LintId::of(&exhaustive_enums::EXHAUSTIVE_ENUMS),
         LintId::of(&exit::EXIT),
         LintId::of(&float_literal::LOSSY_FLOAT_LITERAL),
         LintId::of(&implicit_return::IMPLICIT_RETURN),
diff --git a/tests/ui/exhaustive_enums.fixed b/tests/ui/exhaustive_enums.fixed
new file mode 100644
index 0000000000000..2d5f0474bc0d8
--- /dev/null
+++ b/tests/ui/exhaustive_enums.fixed
@@ -0,0 +1,24 @@
+// run-rustfix
+
+#![deny(clippy::exhaustive_enums)]
+#![allow(unused)]
+
+fn main() {
+    // nop
+}
+
+#[non_exhaustive]
+enum Exhaustive {
+    Foo,
+    Bar,
+    Baz,
+    Quux(String),
+}
+
+#[non_exhaustive]
+enum NonExhaustive {
+    Foo,
+    Bar,
+    Baz,
+    Quux(String),
+}
diff --git a/tests/ui/exhaustive_enums.rs b/tests/ui/exhaustive_enums.rs
new file mode 100644
index 0000000000000..5c88454ae6121
--- /dev/null
+++ b/tests/ui/exhaustive_enums.rs
@@ -0,0 +1,23 @@
+// run-rustfix
+
+#![deny(clippy::exhaustive_enums)]
+#![allow(unused)]
+
+fn main() {
+    // nop
+}
+
+enum Exhaustive {
+    Foo,
+    Bar,
+    Baz,
+    Quux(String),
+}
+
+#[non_exhaustive]
+enum NonExhaustive {
+    Foo,
+    Bar,
+    Baz,
+    Quux(String),
+}
diff --git a/tests/ui/exhaustive_enums.stderr b/tests/ui/exhaustive_enums.stderr
new file mode 100644
index 0000000000000..ee5a1836267eb
--- /dev/null
+++ b/tests/ui/exhaustive_enums.stderr
@@ -0,0 +1,28 @@
+error: enums should not be exhaustive
+  --> $DIR/exhaustive_enums.rs:10:1
+   |
+LL | / enum Exhaustive {
+LL | |     Foo,
+LL | |     Bar,
+LL | |     Baz,
+LL | |     Quux(String),
+LL | | }
+   | |_^
+   |
+note: the lint level is defined here
+  --> $DIR/exhaustive_enums.rs:3:9
+   |
+LL | #![deny(clippy::exhaustive_enums)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^
+help: try adding #[non_exhaustive]
+   |
+LL | #[non_exhaustive]
+LL | enum Exhaustive {
+LL |     Foo,
+LL |     Bar,
+LL |     Baz,
+LL |     Quux(String),
+ ...
+
+error: aborting due to previous error
+

From dc93188805ac20fbccd7bd616a6b114680e9303a Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Thu, 21 Jan 2021 13:31:15 -0800
Subject: [PATCH 053/108] Make exhaustive_enums a late pass

---
 clippy_lints/src/exhaustive_enums.rs | 8 ++++----
 clippy_lints/src/lib.rs              | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/clippy_lints/src/exhaustive_enums.rs b/clippy_lints/src/exhaustive_enums.rs
index 099171962d3c9..1391ebd9e3125 100644
--- a/clippy_lints/src/exhaustive_enums.rs
+++ b/clippy_lints/src/exhaustive_enums.rs
@@ -1,8 +1,8 @@
 use crate::utils::{snippet_opt, span_lint_and_help, span_lint_and_sugg};
 use if_chain::if_chain;
-use rustc_ast::ast::{Item, ItemKind};
+use rustc_hir::{Item, ItemKind};
 use rustc_errors::Applicability;
-use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
@@ -36,8 +36,8 @@ declare_clippy_lint! {
 
 declare_lint_pass!(ExhaustiveEnums => [EXHAUSTIVE_ENUMS]);
 
-impl EarlyLintPass for ExhaustiveEnums {
-    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
+impl LateLintPass<'_> for ExhaustiveEnums {
+    fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
         if_chain! {
             if let ItemKind::Enum(..) = item.kind;
             if !item.attrs.iter().any(|a| a.has_name(sym::non_exhaustive));
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 465ad3846cecf..becd9f333fd5a 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1098,7 +1098,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box eval_order_dependence::EvalOrderDependence);
     store.register_late_pass(|| box missing_doc::MissingDoc::new());
     store.register_late_pass(|| box missing_inline::MissingInline);
-    store.register_early_pass(move || box exhaustive_enums::ExhaustiveEnums);
+    store.register_late_pass(move || box exhaustive_enums::ExhaustiveEnums);
     store.register_late_pass(|| box if_let_some_result::OkIfLet);
     store.register_late_pass(|| box partialeq_ne_impl::PartialEqNeImpl);
     store.register_late_pass(|| box unused_io_amount::UnusedIoAmount);

From f6cb96ef07ac6197dac5be16adbe2b7950c82d99 Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Thu, 21 Jan 2021 13:34:44 -0800
Subject: [PATCH 054/108] Make exhaustive_enums only warn on exported items

---
 clippy_lints/src/exhaustive_enums.rs |  3 ++-
 tests/ui/exhaustive_enums.fixed      | 22 ++++++++++++++++++++--
 tests/ui/exhaustive_enums.rs         | 22 ++++++++++++++++++++--
 tests/ui/exhaustive_enums.stderr     |  4 ++--
 4 files changed, 44 insertions(+), 7 deletions(-)

diff --git a/clippy_lints/src/exhaustive_enums.rs b/clippy_lints/src/exhaustive_enums.rs
index 1391ebd9e3125..2e1c0728d2c3b 100644
--- a/clippy_lints/src/exhaustive_enums.rs
+++ b/clippy_lints/src/exhaustive_enums.rs
@@ -7,7 +7,7 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
 declare_clippy_lint! {
-    /// **What it does:** Warns on any `enum`s that are not tagged `#[non_exhaustive]`
+    /// **What it does:** Warns on any exported `enum`s that are not tagged `#[non_exhaustive]`
     ///
     /// **Why is this bad?** Exhaustive enums are typically fine, but a project which does
     /// not wish to make a stability commitment around enums may wish to disable them by default.
@@ -40,6 +40,7 @@ impl LateLintPass<'_> for ExhaustiveEnums {
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
         if_chain! {
             if let ItemKind::Enum(..) = item.kind;
+            if cx.access_levels.is_exported(item.hir_id);
             if !item.attrs.iter().any(|a| a.has_name(sym::non_exhaustive));
             then {
                 if let Some(snippet) = snippet_opt(cx, item.span) {
diff --git a/tests/ui/exhaustive_enums.fixed b/tests/ui/exhaustive_enums.fixed
index 2d5f0474bc0d8..71c4a251e3b38 100644
--- a/tests/ui/exhaustive_enums.fixed
+++ b/tests/ui/exhaustive_enums.fixed
@@ -8,15 +8,33 @@ fn main() {
 }
 
 #[non_exhaustive]
-enum Exhaustive {
+pub enum Exhaustive {
     Foo,
     Bar,
     Baz,
     Quux(String),
 }
 
+// no warning, already non_exhaustive
 #[non_exhaustive]
-enum NonExhaustive {
+pub enum NonExhaustive {
+    Foo,
+    Bar,
+    Baz,
+    Quux(String),
+}
+
+// no warning, private
+enum ExhaustivePrivate {
+    Foo,
+    Bar,
+    Baz,
+    Quux(String),
+}
+
+// no warning, private
+#[non_exhaustive]
+enum NonExhaustivePrivate {
     Foo,
     Bar,
     Baz,
diff --git a/tests/ui/exhaustive_enums.rs b/tests/ui/exhaustive_enums.rs
index 5c88454ae6121..45af6851dd1a8 100644
--- a/tests/ui/exhaustive_enums.rs
+++ b/tests/ui/exhaustive_enums.rs
@@ -7,15 +7,33 @@ fn main() {
     // nop
 }
 
-enum Exhaustive {
+pub enum Exhaustive {
     Foo,
     Bar,
     Baz,
     Quux(String),
 }
 
+// no warning, already non_exhaustive
 #[non_exhaustive]
-enum NonExhaustive {
+pub enum NonExhaustive {
+    Foo,
+    Bar,
+    Baz,
+    Quux(String),
+}
+
+// no warning, private
+enum ExhaustivePrivate {
+    Foo,
+    Bar,
+    Baz,
+    Quux(String),
+}
+
+// no warning, private
+#[non_exhaustive]
+enum NonExhaustivePrivate {
     Foo,
     Bar,
     Baz,
diff --git a/tests/ui/exhaustive_enums.stderr b/tests/ui/exhaustive_enums.stderr
index ee5a1836267eb..280c40b00aa31 100644
--- a/tests/ui/exhaustive_enums.stderr
+++ b/tests/ui/exhaustive_enums.stderr
@@ -1,7 +1,7 @@
 error: enums should not be exhaustive
   --> $DIR/exhaustive_enums.rs:10:1
    |
-LL | / enum Exhaustive {
+LL | / pub enum Exhaustive {
 LL | |     Foo,
 LL | |     Bar,
 LL | |     Baz,
@@ -17,7 +17,7 @@ LL | #![deny(clippy::exhaustive_enums)]
 help: try adding #[non_exhaustive]
    |
 LL | #[non_exhaustive]
-LL | enum Exhaustive {
+LL | pub enum Exhaustive {
 LL |     Foo,
 LL |     Bar,
 LL |     Baz,

From 09d4d49299c6614a0ae956980e709a234d21a9ef Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Thu, 21 Jan 2021 13:36:18 -0800
Subject: [PATCH 055/108] ExhaustiveEnums -> ExhaustiveItems

---
 .../src/{exhaustive_enums.rs => exhaustive_items.rs}      | 4 ++--
 clippy_lints/src/lib.rs                                   | 8 ++++----
 .../ui/{exhaustive_enums.fixed => exhaustive_items.fixed} | 0
 tests/ui/{exhaustive_enums.rs => exhaustive_items.rs}     | 0
 .../{exhaustive_enums.stderr => exhaustive_items.stderr}  | 4 ++--
 5 files changed, 8 insertions(+), 8 deletions(-)
 rename clippy_lints/src/{exhaustive_enums.rs => exhaustive_items.rs} (95%)
 rename tests/ui/{exhaustive_enums.fixed => exhaustive_items.fixed} (100%)
 rename tests/ui/{exhaustive_enums.rs => exhaustive_items.rs} (100%)
 rename tests/ui/{exhaustive_enums.stderr => exhaustive_items.stderr} (87%)

diff --git a/clippy_lints/src/exhaustive_enums.rs b/clippy_lints/src/exhaustive_items.rs
similarity index 95%
rename from clippy_lints/src/exhaustive_enums.rs
rename to clippy_lints/src/exhaustive_items.rs
index 2e1c0728d2c3b..0fa6c4b589f04 100644
--- a/clippy_lints/src/exhaustive_enums.rs
+++ b/clippy_lints/src/exhaustive_items.rs
@@ -34,9 +34,9 @@ declare_clippy_lint! {
     "default lint description"
 }
 
-declare_lint_pass!(ExhaustiveEnums => [EXHAUSTIVE_ENUMS]);
+declare_lint_pass!(ExhaustiveItems => [EXHAUSTIVE_ENUMS]);
 
-impl LateLintPass<'_> for ExhaustiveEnums {
+impl LateLintPass<'_> for ExhaustiveItems {
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
         if_chain! {
             if let ItemKind::Enum(..) = item.kind;
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index becd9f333fd5a..a5deebf7d5f19 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -200,7 +200,7 @@ mod escape;
 mod eta_reduction;
 mod eval_order_dependence;
 mod excessive_bools;
-mod exhaustive_enums;
+mod exhaustive_items;
 mod exit;
 mod explicit_write;
 mod fallible_impl_from;
@@ -612,7 +612,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &eval_order_dependence::EVAL_ORDER_DEPENDENCE,
         &excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS,
         &excessive_bools::STRUCT_EXCESSIVE_BOOLS,
-        &exhaustive_enums::EXHAUSTIVE_ENUMS,
+        &exhaustive_items::EXHAUSTIVE_ENUMS,
         &exit::EXIT,
         &explicit_write::EXPLICIT_WRITE,
         &fallible_impl_from::FALLIBLE_IMPL_FROM,
@@ -1098,7 +1098,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box eval_order_dependence::EvalOrderDependence);
     store.register_late_pass(|| box missing_doc::MissingDoc::new());
     store.register_late_pass(|| box missing_inline::MissingInline);
-    store.register_late_pass(move || box exhaustive_enums::ExhaustiveEnums);
+    store.register_late_pass(move || box exhaustive_items::ExhaustiveItems);
     store.register_late_pass(|| box if_let_some_result::OkIfLet);
     store.register_late_pass(|| box partialeq_ne_impl::PartialEqNeImpl);
     store.register_late_pass(|| box unused_io_amount::UnusedIoAmount);
@@ -1249,7 +1249,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&create_dir::CREATE_DIR),
         LintId::of(&dbg_macro::DBG_MACRO),
         LintId::of(&else_if_without_else::ELSE_IF_WITHOUT_ELSE),
-        LintId::of(&exhaustive_enums::EXHAUSTIVE_ENUMS),
+        LintId::of(&exhaustive_items::EXHAUSTIVE_ENUMS),
         LintId::of(&exit::EXIT),
         LintId::of(&float_literal::LOSSY_FLOAT_LITERAL),
         LintId::of(&implicit_return::IMPLICIT_RETURN),
diff --git a/tests/ui/exhaustive_enums.fixed b/tests/ui/exhaustive_items.fixed
similarity index 100%
rename from tests/ui/exhaustive_enums.fixed
rename to tests/ui/exhaustive_items.fixed
diff --git a/tests/ui/exhaustive_enums.rs b/tests/ui/exhaustive_items.rs
similarity index 100%
rename from tests/ui/exhaustive_enums.rs
rename to tests/ui/exhaustive_items.rs
diff --git a/tests/ui/exhaustive_enums.stderr b/tests/ui/exhaustive_items.stderr
similarity index 87%
rename from tests/ui/exhaustive_enums.stderr
rename to tests/ui/exhaustive_items.stderr
index 280c40b00aa31..d00d950efc768 100644
--- a/tests/ui/exhaustive_enums.stderr
+++ b/tests/ui/exhaustive_items.stderr
@@ -1,5 +1,5 @@
 error: enums should not be exhaustive
-  --> $DIR/exhaustive_enums.rs:10:1
+  --> $DIR/exhaustive_items.rs:10:1
    |
 LL | / pub enum Exhaustive {
 LL | |     Foo,
@@ -10,7 +10,7 @@ LL | | }
    | |_^
    |
 note: the lint level is defined here
-  --> $DIR/exhaustive_enums.rs:3:9
+  --> $DIR/exhaustive_items.rs:3:9
    |
 LL | #![deny(clippy::exhaustive_enums)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^

From a905cf6737197096e2aa1b8f384b07ded9e96fd1 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Fri, 22 Jan 2021 00:19:22 +0100
Subject: [PATCH 056/108] Added documentation for common abbreviations

This list was created as a collaborative effort on Zulip and the [thread] is definitely worth a read as we had quite some fun. A big **THANK YOU** goes out to everyone who participated you make this project fun to work on!!!

The Zulip [thread]: https://rust-lang.zulipchat.com/#narrow/stream/257328-clippy/topic/Common.20abbreviations.20in.20basics.2Emd/near/223548065
---
 doc/basics.md | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/doc/basics.md b/doc/basics.md
index 954474a17aa8e..8f2a20bfe2468 100644
--- a/doc/basics.md
+++ b/doc/basics.md
@@ -94,3 +94,22 @@ cargo dev ra_setup
 
 We follow a rustc no merge-commit policy.
 See <https://rustc-dev-guide.rust-lang.org/contributing.html#opening-a-pr>.
+
+## Common Abbreviations
+
+| Abbreviation | Meaning                                |
+| ------------ | -------------------------------------- |
+| UB           | Undefined Behavior                     |
+| FP           | False Positive                         |
+| FN           | False Negative                         |
+| ICE          | Internal Compiler Error                |
+| AST          | Abstract Syntax Tree                   |
+| MIR          | Mid-Level Intermediate Representation  |
+| HIR          | High-Level Intermediate Representation |
+| TCX          | Type context                           |
+
+This is a concise list of abbreviations that can come up during clippy development. An extensive
+genal list can be found in the [rustc-dev-guide glossary][glossary]. Always feel free to ask if
+an abbreviation or meaning is unclear to you.
+
+[glossary]: https://rustc-dev-guide.rust-lang.org/appendix/glossary.html
\ No newline at end of file

From 2d509f8b404b77fd7fa949a13fd38c9f5f51b9fb Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 21 Jan 2021 18:12:46 -0600
Subject: [PATCH 057/108] Check if let guard in collapsible_match

---
 clippy_lints/src/collapsible_match.rs | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/clippy_lints/src/collapsible_match.rs b/clippy_lints/src/collapsible_match.rs
index a34ba2d00a8c7..c75aa2bde9753 100644
--- a/clippy_lints/src/collapsible_match.rs
+++ b/clippy_lints/src/collapsible_match.rs
@@ -85,7 +85,12 @@ fn check_arm(arm: &Arm<'_>, wild_outer_arm: &Arm<'_>, cx: &LateContext<'_>) {
         // the "wild-like" branches must be equal
         if SpanlessEq::new(cx).eq_expr(wild_inner_arm.body, wild_outer_arm.body);
         // the binding must not be used in the if guard
-        if !matches!(arm.guard, Some(Guard::If(guard)) if LocalUsedVisitor::new(binding_id).check_expr(guard));
+        if match arm.guard {
+            None => true,
+            Some(Guard::If(expr) | Guard::IfLet(_, expr)) => {
+                !LocalUsedVisitor::new(binding_id).check_expr(expr)
+            }
+        };
         // ...or anywhere in the inner match
         if !arms_inner.iter().any(|arm| LocalUsedVisitor::new(binding_id).check_arm(arm));
         then {

From e89ad4ba71816cbe6fb1f90743d9229fc824b1c0 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 14 Dec 2020 13:50:53 -0600
Subject: [PATCH 058/108] Fix comment

---
 clippy_lints/src/methods/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 623554ea2d155..c8b69f4fbaead 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3059,7 +3059,7 @@ fn lint_filter_map_map<'tcx>(
     _filter_args: &'tcx [hir::Expr<'_>],
     _map_args: &'tcx [hir::Expr<'_>],
 ) {
-    // lint if caller of `.filter().map()` is an Iterator
+    // lint if caller of `.filter_map().map()` is an Iterator
     if match_trait_method(cx, expr, &paths::ITERATOR) {
         let msg = "called `filter_map(..).map(..)` on an `Iterator`";
         let hint = "this is more succinctly expressed by only calling `.filter_map(..)` instead";

From 7a8660861ecf11474e03823387a50eeaa2c18a57 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 1 Jan 2021 13:00:44 -0600
Subject: [PATCH 059/108] Add expr_fallback to SpanlessEq

---
 clippy_lints/src/utils/hir_utils.rs | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs
index 10120a8805db2..1c7398f17f2e5 100644
--- a/clippy_lints/src/utils/hir_utils.rs
+++ b/clippy_lints/src/utils/hir_utils.rs
@@ -24,6 +24,7 @@ pub struct SpanlessEq<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
     maybe_typeck_results: Option<&'tcx TypeckResults<'tcx>>,
     allow_side_effects: bool,
+    expr_fallback: Option<Box<dyn Fn(&Expr<'_>, &Expr<'_>) -> bool + 'a>>,
 }
 
 impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
@@ -32,6 +33,7 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
             cx,
             maybe_typeck_results: cx.maybe_typeck_results(),
             allow_side_effects: true,
+            expr_fallback: None,
         }
     }
 
@@ -43,6 +45,13 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
         }
     }
 
+    pub fn expr_fallback(self, expr_fallback: impl Fn(&Expr<'_>, &Expr<'_>) -> bool + 'a) -> Self {
+        Self {
+            expr_fallback: Some(Box::new(expr_fallback)),
+            ..self
+        }
+    }
+
     /// Checks whether two statements are the same.
     pub fn eq_stmt(&mut self, left: &Stmt<'_>, right: &Stmt<'_>) -> bool {
         match (&left.kind, &right.kind) {
@@ -81,7 +90,7 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
             }
         }
 
-        match (&reduce_exprkind(&left.kind), &reduce_exprkind(&right.kind)) {
+        let is_eq = match (&reduce_exprkind(&left.kind), &reduce_exprkind(&right.kind)) {
             (&ExprKind::AddrOf(lb, l_mut, ref le), &ExprKind::AddrOf(rb, r_mut, ref re)) => {
                 lb == rb && l_mut == r_mut && self.eq_expr(le, re)
             },
@@ -158,7 +167,8 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
             (&ExprKind::Array(l), &ExprKind::Array(r)) => self.eq_exprs(l, r),
             (&ExprKind::DropTemps(ref le), &ExprKind::DropTemps(ref re)) => self.eq_expr(le, re),
             _ => false,
-        }
+        };
+        is_eq || self.expr_fallback.as_ref().map_or(false, |f| f(left, right))
     }
 
     fn eq_exprs(&mut self, left: &[Expr<'_>], right: &[Expr<'_>]) -> bool {

From c92bdc4dbbd777f6933f7990f87066147a629c8d Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 1 Jan 2021 13:00:09 -0600
Subject: [PATCH 060/108] Split filter_map into manual_filter_map

---
 CHANGELOG.md                      |   1 +
 clippy_lints/src/lib.rs           |   3 +
 clippy_lints/src/methods/mod.rs   | 109 ++++++++++++++++++++++++++----
 tests/ui/filter_methods.stderr    |  12 +---
 tests/ui/manual_filter_map.fixed  |  37 ++++++++++
 tests/ui/manual_filter_map.rs     |  37 ++++++++++
 tests/ui/manual_filter_map.stderr |  22 ++++++
 7 files changed, 198 insertions(+), 23 deletions(-)
 create mode 100644 tests/ui/manual_filter_map.fixed
 create mode 100644 tests/ui/manual_filter_map.rs
 create mode 100644 tests/ui/manual_filter_map.stderr

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 04f042b2debf2..8feb1a148afa3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2035,6 +2035,7 @@ Released 2018-09-13
 [`macro_use_imports`]: https://rust-lang.github.io/rust-clippy/master/index.html#macro_use_imports
 [`main_recursion`]: https://rust-lang.github.io/rust-clippy/master/index.html#main_recursion
 [`manual_async_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_async_fn
+[`manual_filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_filter_map
 [`manual_memcpy`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_memcpy
 [`manual_non_exhaustive`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_non_exhaustive
 [`manual_ok_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_ok_or
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 53764bb73903a..bde9c630c6c79 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -745,6 +745,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &methods::ITER_NTH,
         &methods::ITER_NTH_ZERO,
         &methods::ITER_SKIP_NEXT,
+        &methods::MANUAL_FILTER_MAP,
         &methods::MANUAL_SATURATING_ARITHMETIC,
         &methods::MAP_COLLECT_RESULT_UNIT,
         &methods::MAP_FLATTEN,
@@ -1526,6 +1527,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::ITER_NTH),
         LintId::of(&methods::ITER_NTH_ZERO),
         LintId::of(&methods::ITER_SKIP_NEXT),
+        LintId::of(&methods::MANUAL_FILTER_MAP),
         LintId::of(&methods::MANUAL_SATURATING_ARITHMETIC),
         LintId::of(&methods::MAP_COLLECT_RESULT_UNIT),
         LintId::of(&methods::NEW_RET_NO_SELF),
@@ -1823,6 +1825,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::FILTER_NEXT),
         LintId::of(&methods::FLAT_MAP_IDENTITY),
         LintId::of(&methods::INSPECT_FOR_EACH),
+        LintId::of(&methods::MANUAL_FILTER_MAP),
         LintId::of(&methods::OPTION_AS_REF_DEREF),
         LintId::of(&methods::SEARCH_IS_SOME),
         LintId::of(&methods::SKIP_WHILE_NEXT),
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index c8b69f4fbaead..518d2e67ad16d 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -15,7 +15,8 @@ use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_hir::{TraitItem, TraitItemKind};
+use rustc_hir::def::Res;
+use rustc_hir::{Expr, ExprKind, PatKind, QPath, TraitItem, TraitItemKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass, Lint, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, TraitRef, Ty, TyS};
@@ -450,6 +451,32 @@ declare_clippy_lint! {
     "using combinations of `filter`, `map`, `filter_map` and `flat_map` which can usually be written as a single method call"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for usage of `_.filter(_).map(_)` that can be written more simply
+    /// as `filter_map(_)`.
+    ///
+    /// **Why is this bad?** Redundant code in the `filter` and `map` operations is poor style and
+    /// less performant.
+    ///
+    /// **Known problems:** None.
+    ///
+     /// **Example:**
+    /// Bad:
+    /// ```rust
+    /// (0_i32..10)
+    ///     .filter(|n| n.checked_add(1).is_some())
+    ///     .map(|n| n.checked_add(1).unwrap());
+    /// ```
+    ///
+    /// Good:
+    /// ```rust
+    /// (0_i32..10).filter_map(|n| n.checked_add(1));
+    /// ```
+    pub MANUAL_FILTER_MAP,
+    complexity,
+    "using `_.filter(_).map(_)` in a way that can be written more simply as `filter_map(_)`"
+}
+
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `_.filter_map(_).next()`.
     ///
@@ -1473,6 +1500,7 @@ impl_lint_pass!(Methods => [
     FILTER_NEXT,
     SKIP_WHILE_NEXT,
     FILTER_MAP,
+    MANUAL_FILTER_MAP,
     FILTER_MAP_NEXT,
     FLAT_MAP_IDENTITY,
     FIND_MAP,
@@ -1540,7 +1568,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["next", "filter"] => lint_filter_next(cx, expr, arg_lists[1]),
             ["next", "skip_while"] => lint_skip_while_next(cx, expr, arg_lists[1]),
             ["next", "iter"] => lint_iter_next(cx, expr, arg_lists[1]),
-            ["map", "filter"] => lint_filter_map(cx, expr, arg_lists[1], arg_lists[0]),
+            ["map", "filter"] => lint_filter_map(cx, expr),
             ["map", "filter_map"] => lint_filter_map_map(cx, expr, arg_lists[1], arg_lists[0]),
             ["next", "filter_map"] => lint_filter_map_next(cx, expr, arg_lists[1], self.msrv.as_ref()),
             ["map", "find"] => lint_find_map(cx, expr, arg_lists[1], arg_lists[0]),
@@ -2989,17 +3017,72 @@ fn lint_skip_while_next<'tcx>(
 }
 
 /// lint use of `filter().map()` for `Iterators`
-fn lint_filter_map<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx hir::Expr<'_>,
-    _filter_args: &'tcx [hir::Expr<'_>],
-    _map_args: &'tcx [hir::Expr<'_>],
-) {
-    // lint if caller of `.filter().map()` is an Iterator
-    if match_trait_method(cx, expr, &paths::ITERATOR) {
-        let msg = "called `filter(..).map(..)` on an `Iterator`";
-        let hint = "this is more succinctly expressed by calling `.filter_map(..)` instead";
-        span_lint_and_help(cx, FILTER_MAP, expr.span, msg, None, hint);
+fn lint_filter_map<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+    if_chain! {
+        if let ExprKind::MethodCall(_, _, [map_recv, map_arg], map_span) = expr.kind;
+        if let ExprKind::MethodCall(_, _, [_, filter_arg], filter_span) = map_recv.kind;
+        if match_trait_method(cx, expr, &paths::ITERATOR);
+
+        // filter(|x| ...is_some())...
+        if let ExprKind::Closure(_, _, filter_body_id, ..) = filter_arg.kind;
+        let filter_body = cx.tcx.hir().body(filter_body_id);
+        if let [filter_param] = filter_body.params;
+        // optional ref pattern: `filter(|&x| ..)`
+        let (filter_pat, is_filter_param_ref) = if let PatKind::Ref(ref_pat, _) = filter_param.pat.kind {
+            (ref_pat, true)
+        } else {
+            (filter_param.pat, false)
+        };
+        // closure ends with is_some() or is_ok()
+        if let PatKind::Binding(_, filter_param_id, _, None) = filter_pat.kind;
+        if let ExprKind::MethodCall(path, _, [filter_arg], _) = filter_body.value.kind;
+        if let Some(opt_ty) = cx.typeck_results().expr_ty(filter_arg).ty_adt_def();
+        if let Some(is_result) = if cx.tcx.is_diagnostic_item(sym::option_type, opt_ty.did) {
+            Some(false)
+        } else if cx.tcx.is_diagnostic_item(sym::result_type, opt_ty.did) {
+            Some(true)
+        } else {
+            None
+        };
+        if path.ident.name.as_str() == if is_result { "is_ok" } else { "is_some" };
+
+        // ...map(|x| ...unwrap())
+        if let ExprKind::Closure(_, _, map_body_id, ..) = map_arg.kind;
+        let map_body = cx.tcx.hir().body(map_body_id);
+        if let [map_param] = map_body.params;
+        if let PatKind::Binding(_, map_param_id, map_param_ident, None) = map_param.pat.kind;
+        // closure ends with expect() or unwrap()
+        if let ExprKind::MethodCall(seg, _, [map_arg, ..], _) = map_body.value.kind;
+        if matches!(seg.ident.name, sym::expect | sym::unwrap | sym::unwrap_or);
+
+        let eq_fallback = |a: &Expr<'_>, b: &Expr<'_>| {
+            // in `filter(|x| ..)`, replace `*x` with `x`
+            let a_path = if_chain! {
+                if !is_filter_param_ref;
+                if let ExprKind::Unary(UnOp::UnDeref, expr_path) = a.kind;
+                then { expr_path } else { a }
+            };
+            // let the filter closure arg and the map closure arg be equal
+            if_chain! {
+                if let ExprKind::Path(QPath::Resolved(None, a_path)) = a_path.kind;
+                if let ExprKind::Path(QPath::Resolved(None, b_path)) = b.kind;
+                if a_path.res == Res::Local(filter_param_id);
+                if b_path.res == Res::Local(map_param_id);
+                if TyS::same_type(cx.typeck_results().expr_ty_adjusted(a), cx.typeck_results().expr_ty_adjusted(b));
+                then {
+                    return true;
+                }
+            }
+            false
+        };
+        if SpanlessEq::new(cx).expr_fallback(eq_fallback).eq_expr(filter_arg, map_arg);
+        then {
+            let span = filter_span.to(map_span);
+            let msg = "`filter(..).map(..)` can be simplified as `filter_map(..)`";
+            let to_opt = if is_result { ".ok()" } else { "" };
+            let sugg = format!("filter_map(|{}| {}{})", map_param_ident, snippet(cx, map_arg.span, ".."), to_opt);
+            span_lint_and_sugg(cx, MANUAL_FILTER_MAP, span, msg, "try", sugg, Applicability::MachineApplicable);
+        }
     }
 }
 
diff --git a/tests/ui/filter_methods.stderr b/tests/ui/filter_methods.stderr
index 119226813793c..c7b4f28be3a44 100644
--- a/tests/ui/filter_methods.stderr
+++ b/tests/ui/filter_methods.stderr
@@ -1,12 +1,3 @@
-error: called `filter(..).map(..)` on an `Iterator`
-  --> $DIR/filter_methods.rs:6:21
-   |
-LL |     let _: Vec<_> = vec![5; 6].into_iter().filter(|&x| x == 0).map(|x| x * 2).collect();
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::filter-map` implied by `-D warnings`
-   = help: this is more succinctly expressed by calling `.filter_map(..)` instead
-
 error: called `filter(..).flat_map(..)` on an `Iterator`
   --> $DIR/filter_methods.rs:8:21
    |
@@ -17,6 +8,7 @@ LL | |         .filter(|&x| x == 0)
 LL | |         .flat_map(|x| x.checked_mul(2))
    | |_______________________________________^
    |
+   = note: `-D clippy::filter-map` implied by `-D warnings`
    = help: this is more succinctly expressed by calling `.flat_map(..)` and filtering by returning `iter::empty()`
 
 error: called `filter_map(..).flat_map(..)` on an `Iterator`
@@ -43,5 +35,5 @@ LL | |         .map(|x| x.checked_mul(2))
    |
    = help: this is more succinctly expressed by only calling `.filter_map(..)` instead
 
-error: aborting due to 4 previous errors
+error: aborting due to 3 previous errors
 
diff --git a/tests/ui/manual_filter_map.fixed b/tests/ui/manual_filter_map.fixed
new file mode 100644
index 0000000000000..fc8f58f8ea5cd
--- /dev/null
+++ b/tests/ui/manual_filter_map.fixed
@@ -0,0 +1,37 @@
+// run-rustfix
+#![allow(dead_code)]
+#![warn(clippy::manual_filter_map)]
+#![allow(clippy::redundant_closure)] // FIXME suggestion may have redundant closure
+
+fn main() {
+    // is_some(), unwrap()
+    let _ = (0..).filter_map(|a| to_opt(a));
+
+    // ref pattern, expect()
+    let _ = (0..).filter_map(|a| to_opt(a));
+
+    // is_ok(), unwrap_or()
+    let _ = (0..).filter_map(|a| to_res(a).ok());
+}
+
+fn no_lint() {
+    // no shared code
+    let _ = (0..).filter(|n| *n > 1).map(|n| n + 1);
+
+    // very close but different since filter() provides a reference
+    let _ = (0..).filter(|n| to_opt(n).is_some()).map(|a| to_opt(a).unwrap());
+
+    // similar but different
+    let _ = (0..).filter(|n| to_opt(n).is_some()).map(|n| to_res(n).unwrap());
+    let _ = (0..)
+        .filter(|n| to_opt(n).map(|n| n + 1).is_some())
+        .map(|a| to_opt(a).unwrap());
+}
+
+fn to_opt<T>(_: T) -> Option<T> {
+    unimplemented!()
+}
+
+fn to_res<T>(_: T) -> Result<T, ()> {
+    unimplemented!()
+}
diff --git a/tests/ui/manual_filter_map.rs b/tests/ui/manual_filter_map.rs
new file mode 100644
index 0000000000000..3af4bbee3bf82
--- /dev/null
+++ b/tests/ui/manual_filter_map.rs
@@ -0,0 +1,37 @@
+// run-rustfix
+#![allow(dead_code)]
+#![warn(clippy::manual_filter_map)]
+#![allow(clippy::redundant_closure)] // FIXME suggestion may have redundant closure
+
+fn main() {
+    // is_some(), unwrap()
+    let _ = (0..).filter(|n| to_opt(*n).is_some()).map(|a| to_opt(a).unwrap());
+
+    // ref pattern, expect()
+    let _ = (0..).filter(|&n| to_opt(n).is_some()).map(|a| to_opt(a).expect("hi"));
+
+    // is_ok(), unwrap_or()
+    let _ = (0..).filter(|&n| to_res(n).is_ok()).map(|a| to_res(a).unwrap_or(1));
+}
+
+fn no_lint() {
+    // no shared code
+    let _ = (0..).filter(|n| *n > 1).map(|n| n + 1);
+
+    // very close but different since filter() provides a reference
+    let _ = (0..).filter(|n| to_opt(n).is_some()).map(|a| to_opt(a).unwrap());
+
+    // similar but different
+    let _ = (0..).filter(|n| to_opt(n).is_some()).map(|n| to_res(n).unwrap());
+    let _ = (0..)
+        .filter(|n| to_opt(n).map(|n| n + 1).is_some())
+        .map(|a| to_opt(a).unwrap());
+}
+
+fn to_opt<T>(_: T) -> Option<T> {
+    unimplemented!()
+}
+
+fn to_res<T>(_: T) -> Result<T, ()> {
+    unimplemented!()
+}
diff --git a/tests/ui/manual_filter_map.stderr b/tests/ui/manual_filter_map.stderr
new file mode 100644
index 0000000000000..4d4e2d5c12fe9
--- /dev/null
+++ b/tests/ui/manual_filter_map.stderr
@@ -0,0 +1,22 @@
+error: `filter(..).map(..)` can be simplified as `filter_map(..)`
+  --> $DIR/manual_filter_map.rs:8:19
+   |
+LL |     let _ = (0..).filter(|n| to_opt(*n).is_some()).map(|a| to_opt(a).unwrap());
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `filter_map(|a| to_opt(a))`
+   |
+   = note: `-D clippy::manual-filter-map` implied by `-D warnings`
+
+error: `filter(..).map(..)` can be simplified as `filter_map(..)`
+  --> $DIR/manual_filter_map.rs:11:19
+   |
+LL |     let _ = (0..).filter(|&n| to_opt(n).is_some()).map(|a| to_opt(a).expect("hi"));
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `filter_map(|a| to_opt(a))`
+
+error: `filter(..).map(..)` can be simplified as `filter_map(..)`
+  --> $DIR/manual_filter_map.rs:14:19
+   |
+LL |     let _ = (0..).filter(|&n| to_res(n).is_ok()).map(|a| to_res(a).unwrap_or(1));
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `filter_map(|a| to_res(a).ok())`
+
+error: aborting due to 3 previous errors
+

From a752d31e0a8cd8c7d8549daf421a8b791d1325a4 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 14 Jan 2021 16:36:36 -0600
Subject: [PATCH 061/108] Replace find_map with manual_find_map

---
 CHANGELOG.md                    |  1 +
 clippy_lints/src/lib.rs         |  3 ++
 clippy_lints/src/methods/mod.rs | 64 +++++++++++++++++++++------------
 tests/ui/find_map.stderr        | 26 --------------
 tests/ui/manual_find_map.fixed  | 37 +++++++++++++++++++
 tests/ui/manual_find_map.rs     | 37 +++++++++++++++++++
 tests/ui/manual_find_map.stderr | 22 ++++++++++++
 7 files changed, 141 insertions(+), 49 deletions(-)
 delete mode 100644 tests/ui/find_map.stderr
 create mode 100644 tests/ui/manual_find_map.fixed
 create mode 100644 tests/ui/manual_find_map.rs
 create mode 100644 tests/ui/manual_find_map.stderr

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8feb1a148afa3..7f2de888d35f0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2036,6 +2036,7 @@ Released 2018-09-13
 [`main_recursion`]: https://rust-lang.github.io/rust-clippy/master/index.html#main_recursion
 [`manual_async_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_async_fn
 [`manual_filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_filter_map
+[`manual_find_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_find_map
 [`manual_memcpy`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_memcpy
 [`manual_non_exhaustive`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_non_exhaustive
 [`manual_ok_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_ok_or
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index bde9c630c6c79..b22ddfacf86af 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -746,6 +746,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &methods::ITER_NTH_ZERO,
         &methods::ITER_SKIP_NEXT,
         &methods::MANUAL_FILTER_MAP,
+        &methods::MANUAL_FIND_MAP,
         &methods::MANUAL_SATURATING_ARITHMETIC,
         &methods::MAP_COLLECT_RESULT_UNIT,
         &methods::MAP_FLATTEN,
@@ -1528,6 +1529,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::ITER_NTH_ZERO),
         LintId::of(&methods::ITER_SKIP_NEXT),
         LintId::of(&methods::MANUAL_FILTER_MAP),
+        LintId::of(&methods::MANUAL_FIND_MAP),
         LintId::of(&methods::MANUAL_SATURATING_ARITHMETIC),
         LintId::of(&methods::MAP_COLLECT_RESULT_UNIT),
         LintId::of(&methods::NEW_RET_NO_SELF),
@@ -1826,6 +1828,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::FLAT_MAP_IDENTITY),
         LintId::of(&methods::INSPECT_FOR_EACH),
         LintId::of(&methods::MANUAL_FILTER_MAP),
+        LintId::of(&methods::MANUAL_FIND_MAP),
         LintId::of(&methods::OPTION_AS_REF_DEREF),
         LintId::of(&methods::SEARCH_IS_SOME),
         LintId::of(&methods::SKIP_WHILE_NEXT),
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 518d2e67ad16d..9d07858874676 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -477,6 +477,32 @@ declare_clippy_lint! {
     "using `_.filter(_).map(_)` in a way that can be written more simply as `filter_map(_)`"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for usage of `_.find(_).map(_)` that can be written more simply
+    /// as `find_map(_)`.
+    ///
+    /// **Why is this bad?** Redundant code in the `find` and `map` operations is poor style and
+    /// less performant.
+    ///
+    /// **Known problems:** None.
+    ///
+     /// **Example:**
+    /// Bad:
+    /// ```rust
+    /// (0_i32..10)
+    ///     .find(|n| n.checked_add(1).is_some())
+    ///     .map(|n| n.checked_add(1).unwrap());
+    /// ```
+    ///
+    /// Good:
+    /// ```rust
+    /// (0_i32..10).find_map(|n| n.checked_add(1));
+    /// ```
+    pub MANUAL_FIND_MAP,
+    complexity,
+    "using `_.find(_).map(_)` in a way that can be written more simply as `find_map(_)`"
+}
+
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `_.filter_map(_).next()`.
     ///
@@ -1501,6 +1527,7 @@ impl_lint_pass!(Methods => [
     SKIP_WHILE_NEXT,
     FILTER_MAP,
     MANUAL_FILTER_MAP,
+    MANUAL_FIND_MAP,
     FILTER_MAP_NEXT,
     FLAT_MAP_IDENTITY,
     FIND_MAP,
@@ -1568,10 +1595,10 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["next", "filter"] => lint_filter_next(cx, expr, arg_lists[1]),
             ["next", "skip_while"] => lint_skip_while_next(cx, expr, arg_lists[1]),
             ["next", "iter"] => lint_iter_next(cx, expr, arg_lists[1]),
-            ["map", "filter"] => lint_filter_map(cx, expr),
+            ["map", "filter"] => lint_filter_map(cx, expr, false),
             ["map", "filter_map"] => lint_filter_map_map(cx, expr, arg_lists[1], arg_lists[0]),
             ["next", "filter_map"] => lint_filter_map_next(cx, expr, arg_lists[1], self.msrv.as_ref()),
-            ["map", "find"] => lint_find_map(cx, expr, arg_lists[1], arg_lists[0]),
+            ["map", "find"] => lint_filter_map(cx, expr, true),
             ["flat_map", "filter"] => lint_filter_flat_map(cx, expr, arg_lists[1], arg_lists[0]),
             ["flat_map", "filter_map"] => lint_filter_map_flat_map(cx, expr, arg_lists[1], arg_lists[0]),
             ["flat_map", ..] => lint_flat_map_identity(cx, expr, arg_lists[0], method_spans[0]),
@@ -3016,12 +3043,12 @@ fn lint_skip_while_next<'tcx>(
     }
 }
 
-/// lint use of `filter().map()` for `Iterators`
-fn lint_filter_map<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+/// lint use of `filter().map()` or `find().map()` for `Iterators`
+fn lint_filter_map<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, is_find: bool) {
     if_chain! {
         if let ExprKind::MethodCall(_, _, [map_recv, map_arg], map_span) = expr.kind;
         if let ExprKind::MethodCall(_, _, [_, filter_arg], filter_span) = map_recv.kind;
-        if match_trait_method(cx, expr, &paths::ITERATOR);
+        if match_trait_method(cx, map_recv, &paths::ITERATOR);
 
         // filter(|x| ...is_some())...
         if let ExprKind::Closure(_, _, filter_body_id, ..) = filter_arg.kind;
@@ -3078,10 +3105,16 @@ fn lint_filter_map<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
         if SpanlessEq::new(cx).expr_fallback(eq_fallback).eq_expr(filter_arg, map_arg);
         then {
             let span = filter_span.to(map_span);
-            let msg = "`filter(..).map(..)` can be simplified as `filter_map(..)`";
+            let (filter_name, lint) = if is_find {
+                ("find", MANUAL_FIND_MAP)
+            } else {
+                ("filter", MANUAL_FILTER_MAP)
+            };
+            let msg = format!("`{}(..).map(..)` can be simplified as `{0}_map(..)`", filter_name);
             let to_opt = if is_result { ".ok()" } else { "" };
-            let sugg = format!("filter_map(|{}| {}{})", map_param_ident, snippet(cx, map_arg.span, ".."), to_opt);
-            span_lint_and_sugg(cx, MANUAL_FILTER_MAP, span, msg, "try", sugg, Applicability::MachineApplicable);
+            let sugg = format!("{}_map(|{}| {}{})", filter_name, map_param_ident,
+                snippet(cx, map_arg.span, ".."), to_opt);
+            span_lint_and_sugg(cx, lint, span, &msg, "try", sugg, Applicability::MachineApplicable);
         }
     }
 }
@@ -3120,21 +3153,6 @@ fn lint_filter_map_next<'tcx>(
     }
 }
 
-/// lint use of `find().map()` for `Iterators`
-fn lint_find_map<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx hir::Expr<'_>,
-    _find_args: &'tcx [hir::Expr<'_>],
-    map_args: &'tcx [hir::Expr<'_>],
-) {
-    // lint if caller of `.filter().map()` is an Iterator
-    if match_trait_method(cx, &map_args[0], &paths::ITERATOR) {
-        let msg = "called `find(..).map(..)` on an `Iterator`";
-        let hint = "this is more succinctly expressed by calling `.find_map(..)` instead";
-        span_lint_and_help(cx, FIND_MAP, expr.span, msg, None, hint);
-    }
-}
-
 /// lint use of `filter_map().map()` for `Iterators`
 fn lint_filter_map_map<'tcx>(
     cx: &LateContext<'tcx>,
diff --git a/tests/ui/find_map.stderr b/tests/ui/find_map.stderr
deleted file mode 100644
index aea3cc62afcc4..0000000000000
--- a/tests/ui/find_map.stderr
+++ /dev/null
@@ -1,26 +0,0 @@
-error: called `find(..).map(..)` on an `Iterator`
-  --> $DIR/find_map.rs:20:26
-   |
-LL |     let _: Option<i32> = a.iter().find(|s| s.parse::<i32>().is_ok()).map(|s| s.parse().unwrap());
-   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::find-map` implied by `-D warnings`
-   = help: this is more succinctly expressed by calling `.find_map(..)` instead
-
-error: called `find(..).map(..)` on an `Iterator`
-  --> $DIR/find_map.rs:23:29
-   |
-LL |       let _: Option<Flavor> = desserts_of_the_week
-   |  _____________________________^
-LL | |         .iter()
-LL | |         .find(|dessert| match *dessert {
-LL | |             Dessert::Cake(_) => true,
-...  |
-LL | |             _ => unreachable!(),
-LL | |         });
-   | |__________^
-   |
-   = help: this is more succinctly expressed by calling `.find_map(..)` instead
-
-error: aborting due to 2 previous errors
-
diff --git a/tests/ui/manual_find_map.fixed b/tests/ui/manual_find_map.fixed
new file mode 100644
index 0000000000000..95e97c4fd1ff4
--- /dev/null
+++ b/tests/ui/manual_find_map.fixed
@@ -0,0 +1,37 @@
+// run-rustfix
+#![allow(dead_code)]
+#![warn(clippy::manual_find_map)]
+#![allow(clippy::redundant_closure)] // FIXME suggestion may have redundant closure
+
+fn main() {
+    // is_some(), unwrap()
+    let _ = (0..).find_map(|a| to_opt(a));
+
+    // ref pattern, expect()
+    let _ = (0..).find_map(|a| to_opt(a));
+
+    // is_ok(), unwrap_or()
+    let _ = (0..).find_map(|a| to_res(a).ok());
+}
+
+fn no_lint() {
+    // no shared code
+    let _ = (0..).filter(|n| *n > 1).map(|n| n + 1);
+
+    // very close but different since filter() provides a reference
+    let _ = (0..).find(|n| to_opt(n).is_some()).map(|a| to_opt(a).unwrap());
+
+    // similar but different
+    let _ = (0..).find(|n| to_opt(n).is_some()).map(|n| to_res(n).unwrap());
+    let _ = (0..)
+        .find(|n| to_opt(n).map(|n| n + 1).is_some())
+        .map(|a| to_opt(a).unwrap());
+}
+
+fn to_opt<T>(_: T) -> Option<T> {
+    unimplemented!()
+}
+
+fn to_res<T>(_: T) -> Result<T, ()> {
+    unimplemented!()
+}
diff --git a/tests/ui/manual_find_map.rs b/tests/ui/manual_find_map.rs
new file mode 100644
index 0000000000000..cd3c82e3b25ab
--- /dev/null
+++ b/tests/ui/manual_find_map.rs
@@ -0,0 +1,37 @@
+// run-rustfix
+#![allow(dead_code)]
+#![warn(clippy::manual_find_map)]
+#![allow(clippy::redundant_closure)] // FIXME suggestion may have redundant closure
+
+fn main() {
+    // is_some(), unwrap()
+    let _ = (0..).find(|n| to_opt(*n).is_some()).map(|a| to_opt(a).unwrap());
+
+    // ref pattern, expect()
+    let _ = (0..).find(|&n| to_opt(n).is_some()).map(|a| to_opt(a).expect("hi"));
+
+    // is_ok(), unwrap_or()
+    let _ = (0..).find(|&n| to_res(n).is_ok()).map(|a| to_res(a).unwrap_or(1));
+}
+
+fn no_lint() {
+    // no shared code
+    let _ = (0..).filter(|n| *n > 1).map(|n| n + 1);
+
+    // very close but different since filter() provides a reference
+    let _ = (0..).find(|n| to_opt(n).is_some()).map(|a| to_opt(a).unwrap());
+
+    // similar but different
+    let _ = (0..).find(|n| to_opt(n).is_some()).map(|n| to_res(n).unwrap());
+    let _ = (0..)
+        .find(|n| to_opt(n).map(|n| n + 1).is_some())
+        .map(|a| to_opt(a).unwrap());
+}
+
+fn to_opt<T>(_: T) -> Option<T> {
+    unimplemented!()
+}
+
+fn to_res<T>(_: T) -> Result<T, ()> {
+    unimplemented!()
+}
diff --git a/tests/ui/manual_find_map.stderr b/tests/ui/manual_find_map.stderr
new file mode 100644
index 0000000000000..9e7f798df4573
--- /dev/null
+++ b/tests/ui/manual_find_map.stderr
@@ -0,0 +1,22 @@
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_find_map.rs:8:19
+   |
+LL |     let _ = (0..).find(|n| to_opt(*n).is_some()).map(|a| to_opt(a).unwrap());
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|a| to_opt(a))`
+   |
+   = note: `-D clippy::manual-find-map` implied by `-D warnings`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_find_map.rs:11:19
+   |
+LL |     let _ = (0..).find(|&n| to_opt(n).is_some()).map(|a| to_opt(a).expect("hi"));
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|a| to_opt(a))`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_find_map.rs:14:19
+   |
+LL |     let _ = (0..).find(|&n| to_res(n).is_ok()).map(|a| to_res(a).unwrap_or(1));
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|a| to_res(a).ok())`
+
+error: aborting due to 3 previous errors
+

From a22915bf4893e16d64100365d902e52211374a0c Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 14 Dec 2020 14:03:11 -0600
Subject: [PATCH 062/108] Remove unneeded allow's

---
 clippy_dev/src/ra_setup.rs | 2 --
 clippy_lints/src/loops.rs  | 1 -
 2 files changed, 3 deletions(-)

diff --git a/clippy_dev/src/ra_setup.rs b/clippy_dev/src/ra_setup.rs
index 5f5048e79e782..a8a6a2cb1bd6f 100644
--- a/clippy_dev/src/ra_setup.rs
+++ b/clippy_dev/src/ra_setup.rs
@@ -1,5 +1,3 @@
-#![allow(clippy::filter_map)]
-
 use std::fs;
 use std::fs::File;
 use std::io::prelude::*;
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 1c5ab2874b048..c7e1088e35306 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1069,7 +1069,6 @@ fn get_assignments<'a: 'c, 'tcx: 'c, 'c>(
 ) -> impl Iterator<Item = Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)>> + 'c {
     // As the `filter` and `map` below do different things, I think putting together
     // just increases complexity. (cc #3188 and #4193)
-    #[allow(clippy::filter_map)]
     stmts
         .iter()
         .filter_map(move |stmt| match stmt.kind {

From 82bab19a0105ff86176b79a5eae7a9ea7d300cb9 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 14 Jan 2021 16:47:22 -0600
Subject: [PATCH 063/108] Deprecate find_map lint

---
 clippy_lints/src/deprecated_lints.rs |  5 +++++
 clippy_lints/src/lib.rs              |  6 ++++--
 clippy_lints/src/methods/mod.rs      | 23 -----------------------
 3 files changed, 9 insertions(+), 25 deletions(-)

diff --git a/clippy_lints/src/deprecated_lints.rs b/clippy_lints/src/deprecated_lints.rs
index bec0c9f93a0d2..ea386237f20a4 100644
--- a/clippy_lints/src/deprecated_lints.rs
+++ b/clippy_lints/src/deprecated_lints.rs
@@ -166,3 +166,8 @@ declare_deprecated_lint! {
     pub PANIC_PARAMS,
     "this lint has been uplifted to rustc and is now called `panic_fmt`"
 }
+
+declare_deprecated_lint! {
+    pub FIND_MAP,
+    "this lint is replaced by `manual_find_map`, a more specific lint"
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index b22ddfacf86af..7097812e088e7 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -505,6 +505,10 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         "clippy::panic_params",
         "this lint has been uplifted to rustc and is now called `panic_fmt`",
     );
+    store.register_removed(
+        "clippy::find_map",
+        "this lint is replaced by `manual_find_map`, a more specific lint",
+    );
     // end deprecated lints, do not remove this comment, it’s used in `update_lints`
 
     // begin register lints, do not remove this comment, it’s used in `update_lints`
@@ -732,7 +736,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &methods::FILTER_MAP,
         &methods::FILTER_MAP_NEXT,
         &methods::FILTER_NEXT,
-        &methods::FIND_MAP,
         &methods::FLAT_MAP_IDENTITY,
         &methods::FROM_ITER_INSTEAD_OF_COLLECT,
         &methods::GET_UNWRAP,
@@ -1333,7 +1336,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&matches::SINGLE_MATCH_ELSE),
         LintId::of(&methods::FILTER_MAP),
         LintId::of(&methods::FILTER_MAP_NEXT),
-        LintId::of(&methods::FIND_MAP),
         LintId::of(&methods::INEFFICIENT_TO_STRING),
         LintId::of(&methods::MAP_FLATTEN),
         LintId::of(&methods::MAP_UNWRAP_OR),
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 9d07858874676..7a459a440cae4 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -547,28 +547,6 @@ declare_clippy_lint! {
     "call to `flat_map` where `flatten` is sufficient"
 }
 
-declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `_.find(_).map(_)`.
-    ///
-    /// **Why is this bad?** Readability, this can be written more concisely as
-    /// `_.find_map(_)`.
-    ///
-    /// **Known problems:** Often requires a condition + Option/Iterator creation
-    /// inside the closure.
-    ///
-    /// **Example:**
-    /// ```rust
-    ///  (0..3).find(|x| *x == 2).map(|x| x * 2);
-    /// ```
-    /// Can be written as
-    /// ```rust
-    ///  (0..3).find_map(|x| if x == 2 { Some(x * 2) } else { None });
-    /// ```
-    pub FIND_MAP,
-    pedantic,
-    "using a combination of `find` and `map` can usually be written as a single method call"
-}
-
 declare_clippy_lint! {
     /// **What it does:** Checks for an iterator or string search (such as `find()`,
     /// `position()`, or `rposition()`) followed by a call to `is_some()`.
@@ -1530,7 +1508,6 @@ impl_lint_pass!(Methods => [
     MANUAL_FIND_MAP,
     FILTER_MAP_NEXT,
     FLAT_MAP_IDENTITY,
-    FIND_MAP,
     MAP_FLATTEN,
     ITERATOR_STEP_BY_ZERO,
     ITER_NEXT_SLICE,

From 612a7fc18eba9410aa18ba331f2ba982b8875066 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Wed, 20 Jan 2021 17:15:08 -0800
Subject: [PATCH 064/108] Add loop head span to hir

---
 clippy_lints/src/loops.rs             | 8 ++++----
 clippy_lints/src/needless_continue.rs | 2 +-
 clippy_lints/src/shadow.rs            | 2 +-
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 1c5ab2874b048..bbcea387de2cb 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -533,7 +533,7 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
         }
 
         // check for never_loop
-        if let ExprKind::Loop(ref block, _, _) = expr.kind {
+        if let ExprKind::Loop(ref block, _, _, _) = expr.kind {
             match never_loop_block(block, expr.hir_id) {
                 NeverLoopResult::AlwaysBreak => span_lint(cx, NEVER_LOOP, expr.span, "this loop never actually loops"),
                 NeverLoopResult::MayContinueMainLoop | NeverLoopResult::Otherwise => (),
@@ -543,7 +543,7 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
         // check for `loop { if let {} else break }` that could be `while let`
         // (also matches an explicit "match" instead of "if let")
         // (even if the "match" or "if let" is used for declaration)
-        if let ExprKind::Loop(ref block, _, LoopSource::Loop) = expr.kind {
+        if let ExprKind::Loop(ref block, _, LoopSource::Loop, _) = expr.kind {
             // also check for empty `loop {}` statements, skipping those in #[panic_handler]
             if block.stmts.is_empty() && block.expr.is_none() && !is_in_panic_handler(cx, expr) {
                 let msg = "empty `loop {}` wastes CPU cycles";
@@ -738,7 +738,7 @@ fn never_loop_expr(expr: &Expr<'_>, main_loop_id: HirId) -> NeverLoopResult {
         | ExprKind::Assign(ref e1, ref e2, _)
         | ExprKind::AssignOp(_, ref e1, ref e2)
         | ExprKind::Index(ref e1, ref e2) => never_loop_expr_all(&mut [&**e1, &**e2].iter().cloned(), main_loop_id),
-        ExprKind::Loop(ref b, _, _) => {
+        ExprKind::Loop(ref b, _, _, _) => {
             // Break can come from the inner loop so remove them.
             absorb_break(&never_loop_block(b, main_loop_id))
         },
@@ -1314,7 +1314,7 @@ impl<'a, 'tcx> Visitor<'tcx> for SameItemPushVisitor<'a, 'tcx> {
     fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
         match &expr.kind {
             // Non-determinism may occur ... don't give a lint
-            ExprKind::Loop(_, _, _) | ExprKind::Match(_, _, _) => self.should_lint = false,
+            ExprKind::Loop(..) | ExprKind::Match(..) => self.should_lint = false,
             ExprKind::Block(block, _) => self.visit_block(block),
             _ => {},
         }
diff --git a/clippy_lints/src/needless_continue.rs b/clippy_lints/src/needless_continue.rs
index a971d041ca661..bb4d84834043a 100644
--- a/clippy_lints/src/needless_continue.rs
+++ b/clippy_lints/src/needless_continue.rs
@@ -221,7 +221,7 @@ where
 {
     if let ast::ExprKind::While(_, loop_block, label)
     | ast::ExprKind::ForLoop(_, _, loop_block, label)
-    | ast::ExprKind::Loop(loop_block, label) = &expr.kind
+    | ast::ExprKind::Loop(loop_block, label, _) = &expr.kind
     {
         func(loop_block, label.as_ref());
     }
diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index 24da056770c9d..d5b1767e945b9 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -325,7 +325,7 @@ fn check_expr<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, bindings: &mut
         | ExprKind::Field(ref e, _)
         | ExprKind::AddrOf(_, _, ref e)
         | ExprKind::Box(ref e) => check_expr(cx, e, bindings),
-        ExprKind::Block(ref block, _) | ExprKind::Loop(ref block, _, _) => check_block(cx, block, bindings),
+        ExprKind::Block(ref block, _) | ExprKind::Loop(ref block, ..) => check_block(cx, block, bindings),
         // ExprKind::Call
         // ExprKind::MethodCall
         ExprKind::Array(v) | ExprKind::Tup(v) => {

From 3a5ede6ef4b4ef6ae6c6f2c583d4c6620a95fd30 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Thu, 21 Jan 2021 16:48:17 -0800
Subject: [PATCH 065/108] Fix clippy and comment

---
 clippy_lints/src/needless_continue.rs | 2 +-
 clippy_lints/src/utils/author.rs      | 2 +-
 clippy_lints/src/utils/higher.rs      | 4 ++--
 clippy_lints/src/utils/hir_utils.rs   | 4 ++--
 4 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/clippy_lints/src/needless_continue.rs b/clippy_lints/src/needless_continue.rs
index bb4d84834043a..603071a5f4ac4 100644
--- a/clippy_lints/src/needless_continue.rs
+++ b/clippy_lints/src/needless_continue.rs
@@ -221,7 +221,7 @@ where
 {
     if let ast::ExprKind::While(_, loop_block, label)
     | ast::ExprKind::ForLoop(_, _, loop_block, label)
-    | ast::ExprKind::Loop(loop_block, label, _) = &expr.kind
+    | ast::ExprKind::Loop(loop_block, label, ..) = &expr.kind
     {
         func(loop_block, label.as_ref());
     }
diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs
index 43afa65de3e55..ca60d335262b3 100644
--- a/clippy_lints/src/utils/author.rs
+++ b/clippy_lints/src/utils/author.rs
@@ -317,7 +317,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                 self.current = cast_pat;
                 self.visit_expr(expr);
             },
-            ExprKind::Loop(ref body, _, desugaring) => {
+            ExprKind::Loop(ref body, _, desugaring, _) => {
                 let body_pat = self.next("body");
                 let des = loop_desugaring_name(desugaring);
                 let label_pat = self.next("label");
diff --git a/clippy_lints/src/utils/higher.rs b/clippy_lints/src/utils/higher.rs
index 9b3585865da32..42ab9a1e7d247 100644
--- a/clippy_lints/src/utils/higher.rs
+++ b/clippy_lints/src/utils/higher.rs
@@ -142,7 +142,7 @@ pub fn for_loop<'tcx>(
         if let hir::ExprKind::Match(ref iterexpr, ref arms, hir::MatchSource::ForLoopDesugar) = expr.kind;
         if let hir::ExprKind::Call(_, ref iterargs) = iterexpr.kind;
         if iterargs.len() == 1 && arms.len() == 1 && arms[0].guard.is_none();
-        if let hir::ExprKind::Loop(ref block, _, _) = arms[0].body.kind;
+        if let hir::ExprKind::Loop(ref block, ..) = arms[0].body.kind;
         if block.expr.is_none();
         if let [ _, _, ref let_stmt, ref body ] = *block.stmts;
         if let hir::StmtKind::Local(ref local) = let_stmt.kind;
@@ -158,7 +158,7 @@ pub fn for_loop<'tcx>(
 /// `while cond { body }` becomes `(cond, body)`.
 pub fn while_loop<'tcx>(expr: &'tcx hir::Expr<'tcx>) -> Option<(&'tcx hir::Expr<'tcx>, &'tcx hir::Expr<'tcx>)> {
     if_chain! {
-        if let hir::ExprKind::Loop(block, _, hir::LoopSource::While) = &expr.kind;
+        if let hir::ExprKind::Loop(block, _, hir::LoopSource::While, _) = &expr.kind;
         if let hir::Block { expr: Some(expr), .. } = &**block;
         if let hir::ExprKind::Match(cond, arms, hir::MatchSource::WhileDesugar) = &expr.kind;
         if let hir::ExprKind::DropTemps(cond) = &cond.kind;
diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs
index 10120a8805db2..6066383f2ef42 100644
--- a/clippy_lints/src/utils/hir_utils.rs
+++ b/clippy_lints/src/utils/hir_utils.rs
@@ -123,7 +123,7 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
                 self.eq_expr(lc, rc) && self.eq_expr(&**lt, &**rt) && both(le, re, |l, r| self.eq_expr(l, r))
             },
             (&ExprKind::Lit(ref l), &ExprKind::Lit(ref r)) => l.node == r.node,
-            (&ExprKind::Loop(ref lb, ref ll, ref lls), &ExprKind::Loop(ref rb, ref rl, ref rls)) => {
+            (&ExprKind::Loop(ref lb, ref ll, ref lls, _), &ExprKind::Loop(ref rb, ref rl, ref rls, _)) => {
                 lls == rls && self.eq_block(lb, rb) && both(ll, rl, |l, r| l.ident.name == r.ident.name)
             },
             (&ExprKind::Match(ref le, ref la, ref ls), &ExprKind::Match(ref re, ref ra, ref rs)) => {
@@ -560,7 +560,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
             ExprKind::Lit(ref l) => {
                 l.node.hash(&mut self.s);
             },
-            ExprKind::Loop(ref b, ref i, _) => {
+            ExprKind::Loop(ref b, ref i, ..) => {
                 self.hash_block(b);
                 if let Some(i) = *i {
                     self.hash_name(i.ident.name);

From 23662d1353a52be7c35bb3905337f2aadf7c504a Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Fri, 22 Jan 2021 22:51:06 +0900
Subject: [PATCH 066/108] Improve the example in `ref_in_deref`

---
 clippy_lints/src/reference.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/clippy_lints/src/reference.rs b/clippy_lints/src/reference.rs
index 2dfb947b5eb9a..e1450466a7c22 100644
--- a/clippy_lints/src/reference.rs
+++ b/clippy_lints/src/reference.rs
@@ -111,6 +111,12 @@ declare_clippy_lint! {
     /// let point = Point(30, 20);
     /// let x = (&point).0;
     /// ```
+    /// Use instead:
+    /// ```rust
+    /// # struct Point(u32, u32);
+    /// # let point = Point(30, 20);
+    /// let x = point.0;
+    /// ```
     pub REF_IN_DEREF,
     complexity,
     "Use of reference in auto dereference expression."

From 8c00304bbbe79a940b838039f8d679fd70c6b137 Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Fri, 22 Jan 2021 18:07:00 +0100
Subject: [PATCH 067/108] Make more traits of the From/Into family diagnostic
 items

Following traits are now diagnostic items:
- `From` (unchanged)
- `Into`
- `TryFrom`
- `TryInto`

This also adds symbols for those items:
- `into_trait`
- `try_from_trait`
- `try_into_trait`
---
 clippy_lints/src/fallible_impl_from.rs | 7 ++-----
 clippy_lints/src/utils/paths.rs        | 1 -
 2 files changed, 2 insertions(+), 6 deletions(-)

diff --git a/clippy_lints/src/fallible_impl_from.rs b/clippy_lints/src/fallible_impl_from.rs
index 9f389c8d2f9e7..527905e375d28 100644
--- a/clippy_lints/src/fallible_impl_from.rs
+++ b/clippy_lints/src/fallible_impl_from.rs
@@ -1,7 +1,4 @@
-use crate::utils::paths::FROM_TRAIT;
-use crate::utils::{
-    is_expn_of, is_type_diagnostic_item, match_def_path, match_panic_def_id, method_chain_args, span_lint_and_then,
-};
+use crate::utils::{is_expn_of, is_type_diagnostic_item, match_panic_def_id, method_chain_args, span_lint_and_then};
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
@@ -59,7 +56,7 @@ impl<'tcx> LateLintPass<'tcx> for FallibleImplFrom {
         if_chain! {
             if let hir::ItemKind::Impl(impl_) = &item.kind;
             if let Some(impl_trait_ref) = cx.tcx.impl_trait_ref(impl_def_id);
-            if match_def_path(cx, impl_trait_ref.def_id, &FROM_TRAIT);
+            if cx.tcx.is_diagnostic_item(sym::from_trait, impl_trait_ref.def_id);
             then {
                 lint_impl_body(cx, item.span, impl_.items);
             }
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index c0b203b5388dc..432cc5b59f684 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -48,7 +48,6 @@ pub const FN_MUT: [&str; 3] = ["core", "ops", "FnMut"];
 pub const FN_ONCE: [&str; 3] = ["core", "ops", "FnOnce"];
 pub const FROM_FROM: [&str; 4] = ["core", "convert", "From", "from"];
 pub const FROM_ITERATOR: [&str; 5] = ["core", "iter", "traits", "collect", "FromIterator"];
-pub const FROM_TRAIT: [&str; 3] = ["core", "convert", "From"];
 pub const FUTURE_FROM_GENERATOR: [&str; 3] = ["core", "future", "from_generator"];
 pub const HASH: [&str; 3] = ["core", "hash", "Hash"];
 pub const HASHMAP: [&str; 5] = ["std", "collections", "hash", "map", "HashMap"];

From 8cb7e85006853e99e6ba2bf378c801fb53eee8fa Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Thu, 21 Jan 2021 13:41:57 -0800
Subject: [PATCH 068/108] Add exhaustive_structs lint

---
 CHANGELOG.md                         |  1 +
 clippy_lints/src/exhaustive_items.rs | 54 ++++++++++++++---
 clippy_lints/src/lib.rs              |  2 +
 tests/ui/exhaustive_items.fixed      | 86 +++++++++++++++++++---------
 tests/ui/exhaustive_items.rs         | 85 ++++++++++++++++++---------
 tests/ui/exhaustive_items.stderr     | 52 +++++++++++------
 6 files changed, 199 insertions(+), 81 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4cf2125ea2fc0..ccc7eb7e881c2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1939,6 +1939,7 @@ Released 2018-09-13
 [`eval_order_dependence`]: https://rust-lang.github.io/rust-clippy/master/index.html#eval_order_dependence
 [`excessive_precision`]: https://rust-lang.github.io/rust-clippy/master/index.html#excessive_precision
 [`exhaustive_enums`]: https://rust-lang.github.io/rust-clippy/master/index.html#exhaustive_enums
+[`exhaustive_structs`]: https://rust-lang.github.io/rust-clippy/master/index.html#exhaustive_structs
 [`exit`]: https://rust-lang.github.io/rust-clippy/master/index.html#exit
 [`expect_fun_call`]: https://rust-lang.github.io/rust-clippy/master/index.html#expect_fun_call
 [`expect_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#expect_used
diff --git a/clippy_lints/src/exhaustive_items.rs b/clippy_lints/src/exhaustive_items.rs
index 0fa6c4b589f04..d604ad0004fb3 100644
--- a/clippy_lints/src/exhaustive_items.rs
+++ b/clippy_lints/src/exhaustive_items.rs
@@ -1,7 +1,7 @@
 use crate::utils::{snippet_opt, span_lint_and_help, span_lint_and_sugg};
 use if_chain::if_chain;
-use rustc_hir::{Item, ItemKind};
 use rustc_errors::Applicability;
+use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
@@ -10,7 +10,8 @@ declare_clippy_lint! {
     /// **What it does:** Warns on any exported `enum`s that are not tagged `#[non_exhaustive]`
     ///
     /// **Why is this bad?** Exhaustive enums are typically fine, but a project which does
-    /// not wish to make a stability commitment around enums may wish to disable them by default.
+    /// not wish to make a stability commitment around exported enums may wish to
+    /// disable them by default.
     ///
     /// **Known problems:** None.
     ///
@@ -28,25 +29,62 @@ declare_clippy_lint! {
     /// enum Foo {
     ///     Bar,
     ///     Baz
-    /// }    /// ```
+    /// }
+    /// ```
     pub EXHAUSTIVE_ENUMS,
     restriction,
-    "default lint description"
+    "detects exported enums that have not been marked #[non_exhaustive]"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Warns on any exported `structs`s that are not tagged `#[non_exhaustive]`
+    ///
+    /// **Why is this bad?** Exhaustive structs are typically fine, but a project which does
+    /// not wish to make a stability commitment around exported structs may wish to
+    /// disable them by default.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// struct Foo {
+    ///     bar: u8,
+    ///     baz: String,
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// #[non_exhaustive]
+    /// struct Foo {
+    ///     bar: u8,
+    ///     baz: String,
+    /// }
+    /// ```
+    pub EXHAUSTIVE_STRUCTS,
+    restriction,
+    "detects exported structs that have not been marked #[non_exhaustive]"
 }
 
-declare_lint_pass!(ExhaustiveItems => [EXHAUSTIVE_ENUMS]);
+declare_lint_pass!(ExhaustiveItems => [EXHAUSTIVE_ENUMS, EXHAUSTIVE_STRUCTS]);
 
 impl LateLintPass<'_> for ExhaustiveItems {
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
         if_chain! {
-            if let ItemKind::Enum(..) = item.kind;
+            if let ItemKind::Enum(..) | ItemKind::Struct(..) = item.kind;
             if cx.access_levels.is_exported(item.hir_id);
             if !item.attrs.iter().any(|a| a.has_name(sym::non_exhaustive));
             then {
+                let lint = if let ItemKind::Enum(..) = item.kind {
+                    EXHAUSTIVE_ENUMS
+                } else {
+                    EXHAUSTIVE_STRUCTS
+                };
+
                 if let Some(snippet) = snippet_opt(cx, item.span) {
                     span_lint_and_sugg(
                         cx,
-                        EXHAUSTIVE_ENUMS,
+                        lint,
                         item.span,
                         "enums should not be exhaustive",
                         "try adding #[non_exhaustive]",
@@ -56,7 +94,7 @@ impl LateLintPass<'_> for ExhaustiveItems {
                 } else {
                     span_lint_and_help(
                         cx,
-                        EXHAUSTIVE_ENUMS,
+                        lint,
                         item.span,
                         "enums should not be exhaustive",
                         None,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index a5deebf7d5f19..91c74026f641f 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -613,6 +613,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS,
         &excessive_bools::STRUCT_EXCESSIVE_BOOLS,
         &exhaustive_items::EXHAUSTIVE_ENUMS,
+        &exhaustive_items::EXHAUSTIVE_STRUCTS,
         &exit::EXIT,
         &explicit_write::EXPLICIT_WRITE,
         &fallible_impl_from::FALLIBLE_IMPL_FROM,
@@ -1250,6 +1251,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&dbg_macro::DBG_MACRO),
         LintId::of(&else_if_without_else::ELSE_IF_WITHOUT_ELSE),
         LintId::of(&exhaustive_items::EXHAUSTIVE_ENUMS),
+        LintId::of(&exhaustive_items::EXHAUSTIVE_STRUCTS),
         LintId::of(&exit::EXIT),
         LintId::of(&float_literal::LOSSY_FLOAT_LITERAL),
         LintId::of(&implicit_return::IMPLICIT_RETURN),
diff --git a/tests/ui/exhaustive_items.fixed b/tests/ui/exhaustive_items.fixed
index 71c4a251e3b38..bc146c6afc5e4 100644
--- a/tests/ui/exhaustive_items.fixed
+++ b/tests/ui/exhaustive_items.fixed
@@ -1,42 +1,72 @@
 // run-rustfix
 
-#![deny(clippy::exhaustive_enums)]
+#![deny(clippy::exhaustive_enums, clippy::exhaustive_structs)]
 #![allow(unused)]
 
 fn main() {
     // nop
 }
 
-#[non_exhaustive]
+pub mod enums {
+    #[non_exhaustive]
 pub enum Exhaustive {
-    Foo,
-    Bar,
-    Baz,
-    Quux(String),
-}
+        Foo,
+        Bar,
+        Baz,
+        Quux(String),
+    }
 
-// no warning, already non_exhaustive
-#[non_exhaustive]
-pub enum NonExhaustive {
-    Foo,
-    Bar,
-    Baz,
-    Quux(String),
-}
+    // no warning, already non_exhaustive
+    #[non_exhaustive]
+    pub enum NonExhaustive {
+        Foo,
+        Bar,
+        Baz,
+        Quux(String),
+    }
+
+    // no warning, private
+    enum ExhaustivePrivate {
+        Foo,
+        Bar,
+        Baz,
+        Quux(String),
+    }
 
-// no warning, private
-enum ExhaustivePrivate {
-    Foo,
-    Bar,
-    Baz,
-    Quux(String),
+    // no warning, private
+    #[non_exhaustive]
+    enum NonExhaustivePrivate {
+        Foo,
+        Bar,
+        Baz,
+        Quux(String),
+    }
 }
 
-// no warning, private
-#[non_exhaustive]
-enum NonExhaustivePrivate {
-    Foo,
-    Bar,
-    Baz,
-    Quux(String),
+pub mod structs {
+    #[non_exhaustive]
+pub struct Exhaustive {
+        foo: u8,
+        bar: String,
+    }
+
+    // no warning, already non_exhaustive
+    #[non_exhaustive]
+    pub struct NonExhaustive {
+        foo: u8,
+        bar: String,
+    }
+
+    // no warning, private
+    struct ExhaustivePrivate {
+        foo: u8,
+        bar: String,
+    }
+
+    // no warning, private
+    #[non_exhaustive]
+    struct NonExhaustivePrivate {
+        foo: u8,
+        bar: String,
+    }
 }
diff --git a/tests/ui/exhaustive_items.rs b/tests/ui/exhaustive_items.rs
index 45af6851dd1a8..ed86b50be30a1 100644
--- a/tests/ui/exhaustive_items.rs
+++ b/tests/ui/exhaustive_items.rs
@@ -1,41 +1,70 @@
 // run-rustfix
 
-#![deny(clippy::exhaustive_enums)]
+#![deny(clippy::exhaustive_enums, clippy::exhaustive_structs)]
 #![allow(unused)]
 
 fn main() {
     // nop
 }
 
-pub enum Exhaustive {
-    Foo,
-    Bar,
-    Baz,
-    Quux(String),
-}
+pub mod enums {
+    pub enum Exhaustive {
+        Foo,
+        Bar,
+        Baz,
+        Quux(String),
+    }
 
-// no warning, already non_exhaustive
-#[non_exhaustive]
-pub enum NonExhaustive {
-    Foo,
-    Bar,
-    Baz,
-    Quux(String),
-}
+    // no warning, already non_exhaustive
+    #[non_exhaustive]
+    pub enum NonExhaustive {
+        Foo,
+        Bar,
+        Baz,
+        Quux(String),
+    }
+
+    // no warning, private
+    enum ExhaustivePrivate {
+        Foo,
+        Bar,
+        Baz,
+        Quux(String),
+    }
 
-// no warning, private
-enum ExhaustivePrivate {
-    Foo,
-    Bar,
-    Baz,
-    Quux(String),
+    // no warning, private
+    #[non_exhaustive]
+    enum NonExhaustivePrivate {
+        Foo,
+        Bar,
+        Baz,
+        Quux(String),
+    }
 }
 
-// no warning, private
-#[non_exhaustive]
-enum NonExhaustivePrivate {
-    Foo,
-    Bar,
-    Baz,
-    Quux(String),
+pub mod structs {
+    pub struct Exhaustive {
+        foo: u8,
+        bar: String,
+    }
+
+    // no warning, already non_exhaustive
+    #[non_exhaustive]
+    pub struct NonExhaustive {
+        foo: u8,
+        bar: String,
+    }
+
+    // no warning, private
+    struct ExhaustivePrivate {
+        foo: u8,
+        bar: String,
+    }
+
+    // no warning, private
+    #[non_exhaustive]
+    struct NonExhaustivePrivate {
+        foo: u8,
+        bar: String,
+    }
 }
diff --git a/tests/ui/exhaustive_items.stderr b/tests/ui/exhaustive_items.stderr
index d00d950efc768..7e286e65949a3 100644
--- a/tests/ui/exhaustive_items.stderr
+++ b/tests/ui/exhaustive_items.stderr
@@ -1,28 +1,46 @@
 error: enums should not be exhaustive
-  --> $DIR/exhaustive_items.rs:10:1
+  --> $DIR/exhaustive_items.rs:11:5
    |
-LL | / pub enum Exhaustive {
-LL | |     Foo,
-LL | |     Bar,
-LL | |     Baz,
-LL | |     Quux(String),
-LL | | }
-   | |_^
+LL | /     pub enum Exhaustive {
+LL | |         Foo,
+LL | |         Bar,
+LL | |         Baz,
+LL | |         Quux(String),
+LL | |     }
+   | |_____^
    |
 note: the lint level is defined here
-  --> $DIR/exhaustive_items.rs:3:9
+  --> $DIR/exhaustive_items.rs:3:35
    |
-LL | #![deny(clippy::exhaustive_enums)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^
+LL | #![deny(clippy::exhaustive_enums, clippy::exhaustive_structs)]
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^
 help: try adding #[non_exhaustive]
    |
-LL | #[non_exhaustive]
+LL |     #[non_exhaustive]
 LL | pub enum Exhaustive {
-LL |     Foo,
-LL |     Bar,
-LL |     Baz,
-LL |     Quux(String),
+LL |         Foo,
+LL |         Bar,
+LL |         Baz,
+LL |         Quux(String),
  ...
 
-error: aborting due to previous error
+error: enums should not be exhaustive
+  --> $DIR/exhaustive_items.rs:46:5
+   |
+LL | /     pub struct Exhaustive {
+LL | |         foo: u8,
+LL | |         bar: String,
+LL | |     }
+   | |_____^
+   |
+help: try adding #[non_exhaustive]
+   |
+LL |     #[non_exhaustive]
+LL | pub struct Exhaustive {
+LL |         foo: u8,
+LL |         bar: String,
+LL |     }
+   |
+
+error: aborting due to 2 previous errors
 

From 752274eabdd9be991c9a4e11850890301b697032 Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Thu, 21 Jan 2021 14:00:25 -0800
Subject: [PATCH 069/108] Fix indentation of suggestion

---
 clippy_lints/src/exhaustive_items.rs | 5 +++--
 tests/ui/exhaustive_items.fixed      | 4 ++--
 tests/ui/exhaustive_items.stderr     | 4 ++--
 3 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/clippy_lints/src/exhaustive_items.rs b/clippy_lints/src/exhaustive_items.rs
index d604ad0004fb3..bbcf9bfea27db 100644
--- a/clippy_lints/src/exhaustive_items.rs
+++ b/clippy_lints/src/exhaustive_items.rs
@@ -1,4 +1,4 @@
-use crate::utils::{snippet_opt, span_lint_and_help, span_lint_and_sugg};
+use crate::utils::{indent_of, snippet_opt, span_lint_and_help, span_lint_and_sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Item, ItemKind};
@@ -82,13 +82,14 @@ impl LateLintPass<'_> for ExhaustiveItems {
                 };
 
                 if let Some(snippet) = snippet_opt(cx, item.span) {
+                    let indent = " ".repeat(indent_of(cx, item.span).unwrap_or(0));
                     span_lint_and_sugg(
                         cx,
                         lint,
                         item.span,
                         "enums should not be exhaustive",
                         "try adding #[non_exhaustive]",
-                        format!("#[non_exhaustive]\n{}", snippet),
+                        format!("#[non_exhaustive]\n{}{}", indent, snippet),
                         Applicability::MaybeIncorrect,
                     );
                 } else {
diff --git a/tests/ui/exhaustive_items.fixed b/tests/ui/exhaustive_items.fixed
index bc146c6afc5e4..7e355d2a58b33 100644
--- a/tests/ui/exhaustive_items.fixed
+++ b/tests/ui/exhaustive_items.fixed
@@ -9,7 +9,7 @@ fn main() {
 
 pub mod enums {
     #[non_exhaustive]
-pub enum Exhaustive {
+    pub enum Exhaustive {
         Foo,
         Bar,
         Baz,
@@ -45,7 +45,7 @@ pub enum Exhaustive {
 
 pub mod structs {
     #[non_exhaustive]
-pub struct Exhaustive {
+    pub struct Exhaustive {
         foo: u8,
         bar: String,
     }
diff --git a/tests/ui/exhaustive_items.stderr b/tests/ui/exhaustive_items.stderr
index 7e286e65949a3..1716c8e2cb549 100644
--- a/tests/ui/exhaustive_items.stderr
+++ b/tests/ui/exhaustive_items.stderr
@@ -17,7 +17,7 @@ LL | #![deny(clippy::exhaustive_enums, clippy::exhaustive_structs)]
 help: try adding #[non_exhaustive]
    |
 LL |     #[non_exhaustive]
-LL | pub enum Exhaustive {
+LL |     pub enum Exhaustive {
 LL |         Foo,
 LL |         Bar,
 LL |         Baz,
@@ -36,7 +36,7 @@ LL | |     }
 help: try adding #[non_exhaustive]
    |
 LL |     #[non_exhaustive]
-LL | pub struct Exhaustive {
+LL |     pub struct Exhaustive {
 LL |         foo: u8,
 LL |         bar: String,
 LL |     }

From 65d003a1128e9234730a66c79065afdabb31afa0 Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Fri, 22 Jan 2021 12:08:46 -0800
Subject: [PATCH 070/108] Clean up suggestion span; clarify help message

---
 clippy_lints/src/exhaustive_items.rs | 27 ++++++++++++++++-----------
 tests/ui/exhaustive_items.stderr     | 22 ++++++++++------------
 2 files changed, 26 insertions(+), 23 deletions(-)

diff --git a/clippy_lints/src/exhaustive_items.rs b/clippy_lints/src/exhaustive_items.rs
index bbcf9bfea27db..4749e36238cb5 100644
--- a/clippy_lints/src/exhaustive_items.rs
+++ b/clippy_lints/src/exhaustive_items.rs
@@ -1,4 +1,4 @@
-use crate::utils::{indent_of, snippet_opt, span_lint_and_help, span_lint_and_sugg};
+use crate::utils::{indent_of, snippet_opt, span_lint_and_help, span_lint_and_then};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Item, ItemKind};
@@ -75,29 +75,34 @@ impl LateLintPass<'_> for ExhaustiveItems {
             if cx.access_levels.is_exported(item.hir_id);
             if !item.attrs.iter().any(|a| a.has_name(sym::non_exhaustive));
             then {
-                let lint = if let ItemKind::Enum(..) = item.kind {
-                    EXHAUSTIVE_ENUMS
+                let (lint, msg) = if let ItemKind::Enum(..) = item.kind {
+                    (EXHAUSTIVE_ENUMS, "exported enums should not be exhaustive")
                 } else {
-                    EXHAUSTIVE_STRUCTS
+                    (EXHAUSTIVE_STRUCTS, "exported structs should not be exhaustive")
                 };
+                let suggestion_span = item.span.until(item.ident.span);
 
-                if let Some(snippet) = snippet_opt(cx, item.span) {
+                if let Some(snippet) = snippet_opt(cx, suggestion_span) {
                     let indent = " ".repeat(indent_of(cx, item.span).unwrap_or(0));
-                    span_lint_and_sugg(
+                    span_lint_and_then(
                         cx,
                         lint,
                         item.span,
-                        "enums should not be exhaustive",
-                        "try adding #[non_exhaustive]",
-                        format!("#[non_exhaustive]\n{}{}", indent, snippet),
-                        Applicability::MaybeIncorrect,
+                        msg,
+                        |diag| {
+                            let sugg = format!("#[non_exhaustive]\n{}{}", indent, snippet);
+                            diag.span_suggestion(suggestion_span,
+                                                 "try adding #[non_exhaustive]",
+                                                 sugg,
+                                                 Applicability::MaybeIncorrect);
+                        }
                     );
                 } else {
                     span_lint_and_help(
                         cx,
                         lint,
                         item.span,
-                        "enums should not be exhaustive",
+                        msg,
                         None,
                         "try adding #[non_exhaustive]",
                     );
diff --git a/tests/ui/exhaustive_items.stderr b/tests/ui/exhaustive_items.stderr
index 1716c8e2cb549..a24e64b67058a 100644
--- a/tests/ui/exhaustive_items.stderr
+++ b/tests/ui/exhaustive_items.stderr
@@ -1,4 +1,4 @@
-error: enums should not be exhaustive
+error: exported enums should not be exhaustive
   --> $DIR/exhaustive_items.rs:11:5
    |
 LL | /     pub enum Exhaustive {
@@ -10,21 +10,17 @@ LL | |     }
    | |_____^
    |
 note: the lint level is defined here
-  --> $DIR/exhaustive_items.rs:3:35
+  --> $DIR/exhaustive_items.rs:3:9
    |
 LL | #![deny(clippy::exhaustive_enums, clippy::exhaustive_structs)]
-   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^
 help: try adding #[non_exhaustive]
    |
 LL |     #[non_exhaustive]
 LL |     pub enum Exhaustive {
-LL |         Foo,
-LL |         Bar,
-LL |         Baz,
-LL |         Quux(String),
- ...
+   |
 
-error: enums should not be exhaustive
+error: exported structs should not be exhaustive
   --> $DIR/exhaustive_items.rs:46:5
    |
 LL | /     pub struct Exhaustive {
@@ -33,13 +29,15 @@ LL | |         bar: String,
 LL | |     }
    | |_____^
    |
+note: the lint level is defined here
+  --> $DIR/exhaustive_items.rs:3:35
+   |
+LL | #![deny(clippy::exhaustive_enums, clippy::exhaustive_structs)]
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^
 help: try adding #[non_exhaustive]
    |
 LL |     #[non_exhaustive]
 LL |     pub struct Exhaustive {
-LL |         foo: u8,
-LL |         bar: String,
-LL |     }
    |
 
 error: aborting due to 2 previous errors

From 66afdd1f4292e7fda6ea89113c0c8343e3321d99 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 21 Jan 2021 19:21:12 -0600
Subject: [PATCH 071/108] Enhance collapsible_match for adjusted bindings

---
 clippy_lints/src/collapsible_match.rs | 22 +++++++++++++---
 tests/ui/collapsible_match2.rs        | 29 ++++++++++++++++++++
 tests/ui/collapsible_match2.stderr    | 38 ++++++++++++++++++++++++++-
 3 files changed, 85 insertions(+), 4 deletions(-)

diff --git a/clippy_lints/src/collapsible_match.rs b/clippy_lints/src/collapsible_match.rs
index c75aa2bde9753..604ba10204697 100644
--- a/clippy_lints/src/collapsible_match.rs
+++ b/clippy_lints/src/collapsible_match.rs
@@ -2,7 +2,7 @@ use crate::utils::visitors::LocalUsedVisitor;
 use crate::utils::{span_lint_and_then, SpanlessEq};
 use if_chain::if_chain;
 use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
-use rustc_hir::{Arm, Expr, ExprKind, Guard, HirId, Pat, PatKind, QPath, StmtKind};
+use rustc_hir::{Arm, Expr, ExprKind, Guard, HirId, Pat, PatKind, QPath, StmtKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{DefIdTree, TyCtxt};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -72,8 +72,7 @@ fn check_arm(arm: &Arm<'_>, wild_outer_arm: &Arm<'_>, cx: &LateContext<'_>) {
         if arms_inner.iter().all(|arm| arm.guard.is_none());
         // match expression must be a local binding
         // match <local> { .. }
-        if let ExprKind::Path(QPath::Resolved(None, path)) = expr_in.kind;
-        if let Res::Local(binding_id) = path.res;
+        if let Some(binding_id) = addr_adjusted_binding(expr_in, cx);
         // one of the branches must be "wild-like"
         if let Some(wild_inner_arm_idx) = arms_inner.iter().rposition(|arm_inner| arm_is_wild_like(arm_inner, cx.tcx));
         let (wild_inner_arm, non_wild_inner_arm) =
@@ -175,3 +174,20 @@ fn is_none_ctor(res: Res, tcx: TyCtxt<'_>) -> bool {
     }
     false
 }
+
+/// Retrieves a binding ID with optional `&` and/or `*` operators removed. (e.g. `&**foo`)
+/// Returns `None` if a non-reference type is de-referenced.
+/// For example, if `Vec` is de-referenced to a slice, `None` is returned.
+fn addr_adjusted_binding(mut expr: &Expr<'_>, cx: &LateContext<'_>) -> Option<HirId> {
+    loop {
+        match expr.kind {
+            ExprKind::AddrOf(_, _, e) => expr = e,
+            ExprKind::Path(QPath::Resolved(None, path)) => match path.res {
+                Res::Local(binding_id) => break Some(binding_id),
+                _ => break None,
+            },
+            ExprKind::Unary(UnOp::UnDeref, e) if cx.typeck_results().expr_ty(e).is_ref() => expr = e,
+            _ => break None,
+        }
+    }
+}
diff --git a/tests/ui/collapsible_match2.rs b/tests/ui/collapsible_match2.rs
index d571ac4ab693e..8372a21247734 100644
--- a/tests/ui/collapsible_match2.rs
+++ b/tests/ui/collapsible_match2.rs
@@ -40,6 +40,35 @@ fn lint_cases(opt_opt: Option<Option<u32>>, res_opt: Result<Option<u32>, String>
         // there is still a better way to write this.
         mac!(res_opt => Ok(val), val => Some(n), foo(n));
     }
+
+    // deref reference value
+    match Some(&[1]) {
+        Some(s) => match *s {
+            [n] => foo(n),
+            _ => (),
+        },
+        _ => (),
+    }
+
+    // ref pattern and deref
+    match Some(&[1]) {
+        Some(ref s) => match &*s {
+            [n] => foo(n),
+            _ => (),
+        },
+        _ => (),
+    }
+}
+
+fn no_lint() {
+    // deref inner value (cannot pattern match with Vec)
+    match Some(vec![1]) {
+        Some(s) => match *s {
+            [n] => foo(n),
+            _ => (),
+        },
+        _ => (),
+    }
 }
 
 fn make<T>() -> T {
diff --git a/tests/ui/collapsible_match2.stderr b/tests/ui/collapsible_match2.stderr
index 490d82d12cd59..b2eb457d17326 100644
--- a/tests/ui/collapsible_match2.stderr
+++ b/tests/ui/collapsible_match2.stderr
@@ -57,5 +57,41 @@ LL |         mac!(res_opt => Ok(val), val => Some(n), foo(n));
    |                            Replace this binding
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 3 previous errors
+error: Unnecessary nested match
+  --> $DIR/collapsible_match2.rs:46:20
+   |
+LL |           Some(s) => match *s {
+   |  ____________________^
+LL | |             [n] => foo(n),
+LL | |             _ => (),
+LL | |         },
+   | |_________^
+   |
+help: The outer pattern can be modified to include the inner pattern.
+  --> $DIR/collapsible_match2.rs:46:14
+   |
+LL |         Some(s) => match *s {
+   |              ^ Replace this binding
+LL |             [n] => foo(n),
+   |             ^^^ with this pattern
+
+error: Unnecessary nested match
+  --> $DIR/collapsible_match2.rs:55:24
+   |
+LL |           Some(ref s) => match &*s {
+   |  ________________________^
+LL | |             [n] => foo(n),
+LL | |             _ => (),
+LL | |         },
+   | |_________^
+   |
+help: The outer pattern can be modified to include the inner pattern.
+  --> $DIR/collapsible_match2.rs:55:14
+   |
+LL |         Some(ref s) => match &*s {
+   |              ^^^^^ Replace this binding
+LL |             [n] => foo(n),
+   |             ^^^ with this pattern
+
+error: aborting due to 5 previous errors
 

From 50abde20c901cf815480f0b494234025c315cc7f Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 21 Jan 2021 19:25:22 -0600
Subject: [PATCH 072/108] Fix dogfood

---
 clippy_lints/src/main_recursion.rs | 3 +--
 clippy_lints/src/ptr.rs            | 3 +--
 clippy_lints/src/utils/higher.rs   | 3 +--
 clippy_lints/src/utils/mod.rs      | 3 +--
 4 files changed, 4 insertions(+), 8 deletions(-)

diff --git a/clippy_lints/src/main_recursion.rs b/clippy_lints/src/main_recursion.rs
index eceae706e4fc7..1ed3f3de83908 100644
--- a/clippy_lints/src/main_recursion.rs
+++ b/clippy_lints/src/main_recursion.rs
@@ -43,8 +43,7 @@ impl LateLintPass<'_> for MainRecursion {
 
         if_chain! {
             if let ExprKind::Call(func, _) = &expr.kind;
-            if let ExprKind::Path(path) = &func.kind;
-            if let QPath::Resolved(_, path) = &path;
+            if let ExprKind::Path(QPath::Resolved(_, path)) = &func.kind;
             if let Some(def_id) = path.res.opt_def_id();
             if is_entrypoint_fn(cx, def_id);
             then {
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index c6329a1381c90..b5aa34111402c 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -263,8 +263,7 @@ fn check_fn(cx: &LateContext<'_>, decl: &FnDecl<'_>, fn_id: HirId, opt_body_id:
             } else if match_type(cx, ty, &paths::COW) {
                 if_chain! {
                     if let TyKind::Rptr(_, MutTy { ref ty, ..} ) = arg.kind;
-                    if let TyKind::Path(ref path) = ty.kind;
-                    if let QPath::Resolved(None, ref pp) = *path;
+                    if let TyKind::Path(QPath::Resolved(None, ref pp)) = ty.kind;
                     if let [ref bx] = *pp.segments;
                     if let Some(ref params) = bx.args;
                     if !params.parenthesized;
diff --git a/clippy_lints/src/utils/higher.rs b/clippy_lints/src/utils/higher.rs
index 9b3585865da32..bb71d95a7e2b4 100644
--- a/clippy_lints/src/utils/higher.rs
+++ b/clippy_lints/src/utils/higher.rs
@@ -158,8 +158,7 @@ pub fn for_loop<'tcx>(
 /// `while cond { body }` becomes `(cond, body)`.
 pub fn while_loop<'tcx>(expr: &'tcx hir::Expr<'tcx>) -> Option<(&'tcx hir::Expr<'tcx>, &'tcx hir::Expr<'tcx>)> {
     if_chain! {
-        if let hir::ExprKind::Loop(block, _, hir::LoopSource::While) = &expr.kind;
-        if let hir::Block { expr: Some(expr), .. } = &**block;
+        if let hir::ExprKind::Loop(hir::Block { expr: Some(expr), .. }, _, hir::LoopSource::While) = &expr.kind;
         if let hir::ExprKind::Match(cond, arms, hir::MatchSource::WhileDesugar) = &expr.kind;
         if let hir::ExprKind::DropTemps(cond) = &cond.kind;
         if let [hir::Arm { body, .. }, ..] = &arms[..];
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 8698a618f90c2..991fae6b1aaa6 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -1126,8 +1126,7 @@ pub fn is_self(slf: &Param<'_>) -> bool {
 
 pub fn is_self_ty(slf: &hir::Ty<'_>) -> bool {
     if_chain! {
-        if let TyKind::Path(ref qp) = slf.kind;
-        if let QPath::Resolved(None, ref path) = *qp;
+        if let TyKind::Path(QPath::Resolved(None, ref path)) = slf.kind;
         if let Res::SelfTy(..) = path.res;
         then {
             return true

From bec916d02dc3e330e0dc055080207d708978b41d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= <matthias.krueger@famsik.de>
Date: Fri, 18 Dec 2020 13:21:13 +0100
Subject: [PATCH 073/108] cargo dev crater: lay out the base plan

---
 clippy_dev/src/crater.rs | 69 ++++++++++++++++++++++++++++++++++++++++
 clippy_dev/src/lib.rs    |  1 +
 2 files changed, 70 insertions(+)
 create mode 100644 clippy_dev/src/crater.rs

diff --git a/clippy_dev/src/crater.rs b/clippy_dev/src/crater.rs
new file mode 100644
index 0000000000000..fe0fc440316ca
--- /dev/null
+++ b/clippy_dev/src/crater.rs
@@ -0,0 +1,69 @@
+use std::path::PathBuf;
+use std::process::Command;
+
+// represents an archive we download from crates.io
+struct KrateSource {
+    version: String,
+    name: String,
+}
+
+// represents the extracted sourcecode of a crate
+struct Krate {
+    version: String,
+    name: String,
+}
+
+impl KrateSource {
+    fn new(version: &str, name: &str) -> Self {
+        KrateSource {
+            version: version.into(),
+            name: name.into(),
+        }
+    }
+    fn download_and_extract(self) -> Krate {
+        // download
+        // extract
+
+        Krate {
+            version: self.version,
+            name: self.name,
+        }
+    }
+}
+
+impl Krate {
+    fn run_clippy_lints(&self) -> String {
+        todo!();
+    }
+
+
+}
+
+fn build_clippy() {
+    Command::new("cargo")
+        .arg("build")
+        .output()
+        .expect("Failed to build clippy!");
+}
+
+// the main fn
+pub(crate) fn run() {
+    let cargo_clippy_path: PathBuf = PathBuf::from("target/debug/cargo-clippy");
+    let clippy_driver_path: PathBuf = PathBuf::from("target/debug/cargo-driver");
+
+    // crates we want to check:
+    let krates: Vec<KrateSource> = vec![KrateSource::new("cargo", "0.49.0"), KrateSource::new("regex", "1.4.2")];
+
+    build_clippy();
+    // assert that clippy is found
+    assert!(
+        cargo_clippy_path.is_file(),
+        "target/debug/cargo-clippy binary not found!"
+    );
+    assert!(
+        clippy_driver_path.is_file(),
+        "target/debug/clippy-driver binary not found!"
+    );
+
+  let clippy_lint_results: Vec<String> = krates.into_iter().map(|krate|  krate.download_and_extract()).map(|krate| krate.run_clippy_lints()).collect::<Vec<String>>();
+}
diff --git a/clippy_dev/src/lib.rs b/clippy_dev/src/lib.rs
index 17cc08ee10fea..4873769b367e9 100644
--- a/clippy_dev/src/lib.rs
+++ b/clippy_dev/src/lib.rs
@@ -11,6 +11,7 @@ use std::path::{Path, PathBuf};
 use walkdir::WalkDir;
 
 pub mod bless;
+pub mod crater;
 pub mod fmt;
 pub mod new_lint;
 pub mod ra_setup;

From 5353591b1bc7e4fcb886afcd7944619607adb5cb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= <matthias.krueger@famsik.de>
Date: Fri, 18 Dec 2020 14:14:15 +0100
Subject: [PATCH 074/108] cargo dev crater: work on downloading and extracting
 crate sources

---
 clippy_dev/Cargo.toml    |  7 +++++--
 clippy_dev/src/crater.rs | 39 +++++++++++++++++++++++++++++++++------
 2 files changed, 38 insertions(+), 8 deletions(-)

diff --git a/clippy_dev/Cargo.toml b/clippy_dev/Cargo.toml
index b8a4a20114bb8..517e9d250bca5 100644
--- a/clippy_dev/Cargo.toml
+++ b/clippy_dev/Cargo.toml
@@ -1,16 +1,19 @@
 [package]
-name = "clippy_dev"
-version = "0.0.1"
 authors = ["Philipp Hansch <dev@phansch.net>"]
 edition = "2018"
+name = "clippy_dev"
+version = "0.0.1"
 
 [dependencies]
 bytecount = "0.6"
 clap = "2.33"
+flate2 = "1.0.19"
 itertools = "0.9"
 opener = "0.4"
 regex = "1"
 shell-escape = "0.1"
+tar = "0.4.30"
+ureq = "2.0.0-rc3"
 walkdir = "2"
 
 [features]
diff --git a/clippy_dev/src/crater.rs b/clippy_dev/src/crater.rs
index fe0fc440316ca..22b04242885f0 100644
--- a/clippy_dev/src/crater.rs
+++ b/clippy_dev/src/crater.rs
@@ -2,15 +2,18 @@ use std::path::PathBuf;
 use std::process::Command;
 
 // represents an archive we download from crates.io
+#[derive(Debug)]
 struct KrateSource {
     version: String,
     name: String,
 }
 
 // represents the extracted sourcecode of a crate
+#[derive(Debug)]
 struct Krate {
     version: String,
     name: String,
+    path: PathBuf,
 }
 
 impl KrateSource {
@@ -20,13 +23,34 @@ impl KrateSource {
             name: name.into(),
         }
     }
-    fn download_and_extract(self) -> Krate {
+    fn download_and_extract(&self) -> Krate {
+        let extract_dir = PathBuf::from("target/crater/crates");
+
         // download
+        let krate_download_dir = PathBuf::from("target/crater/downloads");
+
+        let url = format!(
+            "https://crates.io/api/v1/crates/{}/{}/download",
+            self.name, self.version
+        );
+        print!("Downloading {}, {}", self.name, self.version);
+
+        let krate_name = format!("{}-{}.crate", &self.name, &self.version);
+        let mut krate_dest = std::fs::File::create(krate_download_dir.join(krate_name)).unwrap();
+        let mut krate_req = ureq::get(&url).call().unwrap().into_reader();
+        std::io::copy(&mut krate_req, &mut krate_dest).unwrap();
+
         // extract
+        let krate = krate_dest;
+        let tar = flate2::read::GzDecoder::new(krate);
+        let mut archiv = tar::Archive::new(tar);
+        let extracted_path = extract_dir.join(format!("{}-{}/", self.name, self.version));
+        archiv.unpack(&extracted_path).expect("Failed to extract!");
 
         Krate {
-            version: self.version,
-            name: self.name,
+            version: self.version.clone(),
+            name: self.name.clone(),
+            path: extracted_path,
         }
     }
 }
@@ -35,8 +59,6 @@ impl Krate {
     fn run_clippy_lints(&self) -> String {
         todo!();
     }
-
-
 }
 
 fn build_clippy() {
@@ -65,5 +87,10 @@ pub(crate) fn run() {
         "target/debug/clippy-driver binary not found!"
     );
 
-  let clippy_lint_results: Vec<String> = krates.into_iter().map(|krate|  krate.download_and_extract()).map(|krate| krate.run_clippy_lints()).collect::<Vec<String>>();
+    // download and extract the crates, then run clippy on them and collect clippys warnings
+    let clippy_lint_results: Vec<String> = krates
+        .into_iter()
+        .map(|krate| krate.download_and_extract())
+        .map(|krate| krate.run_clippy_lints())
+        .collect::<Vec<String>>();
 }

From 30d85942cf4fee5148a6b994c9ec8bd1190a5122 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= <matthias.krueger@famsik.de>
Date: Fri, 18 Dec 2020 14:28:59 +0100
Subject: [PATCH 075/108] crater: hook into main.rs

---
 clippy_dev/src/crater.rs | 4 ++--
 clippy_dev/src/main.rs   | 6 +++++-
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/clippy_dev/src/crater.rs b/clippy_dev/src/crater.rs
index 22b04242885f0..1cf12941c357c 100644
--- a/clippy_dev/src/crater.rs
+++ b/clippy_dev/src/crater.rs
@@ -69,7 +69,7 @@ fn build_clippy() {
 }
 
 // the main fn
-pub(crate) fn run() {
+pub fn run() {
     let cargo_clippy_path: PathBuf = PathBuf::from("target/debug/cargo-clippy");
     let clippy_driver_path: PathBuf = PathBuf::from("target/debug/cargo-driver");
 
@@ -88,7 +88,7 @@ pub(crate) fn run() {
     );
 
     // download and extract the crates, then run clippy on them and collect clippys warnings
-    let clippy_lint_results: Vec<String> = krates
+    let _clippy_lint_results: Vec<String> = krates
         .into_iter()
         .map(|krate| krate.download_and_extract())
         .map(|krate| krate.run_clippy_lints())
diff --git a/clippy_dev/src/main.rs b/clippy_dev/src/main.rs
index 2ea56c42fafd6..6fb8b6f2899b3 100644
--- a/clippy_dev/src/main.rs
+++ b/clippy_dev/src/main.rs
@@ -1,7 +1,7 @@
 #![cfg_attr(feature = "deny-warnings", deny(warnings))]
 
 use clap::{App, Arg, ArgMatches, SubCommand};
-use clippy_dev::{bless, fmt, new_lint, ra_setup, serve, stderr_length_check, update_lints};
+use clippy_dev::{bless, crater, fmt, new_lint, ra_setup, serve, stderr_length_check, update_lints};
 
 fn main() {
     let matches = get_clap_config();
@@ -10,6 +10,9 @@ fn main() {
         ("bless", Some(matches)) => {
             bless::bless(matches.is_present("ignore-timestamp"));
         },
+        ("crater", Some(_)) => {
+            crater::run();
+        },
         ("fmt", Some(matches)) => {
             fmt::run(matches.is_present("check"), matches.is_present("verbose"));
         },
@@ -56,6 +59,7 @@ fn get_clap_config<'a>() -> ArgMatches<'a> {
                         .help("Include files updated before clippy was built"),
                 ),
         )
+        .subcommand(SubCommand::with_name("crater").about("run clippy on a set of crates and check output"))
         .subcommand(
             SubCommand::with_name("fmt")
                 .about("Run rustfmt on all projects and tests")

From 63176834c2a9cc6718a4e7b20238b607331f1f1d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= <matthias.krueger@famsik.de>
Date: Fri, 18 Dec 2020 16:17:53 +0100
Subject: [PATCH 076/108] cargo dev crater: fixes and debug prints

---
 clippy_dev/src/crater.rs | 28 ++++++++++++++++++----------
 1 file changed, 18 insertions(+), 10 deletions(-)

diff --git a/clippy_dev/src/crater.rs b/clippy_dev/src/crater.rs
index 1cf12941c357c..cade6c38bc15d 100644
--- a/clippy_dev/src/crater.rs
+++ b/clippy_dev/src/crater.rs
@@ -17,7 +17,7 @@ struct Krate {
 }
 
 impl KrateSource {
-    fn new(version: &str, name: &str) -> Self {
+    fn new(name: &str, version: &str) -> Self {
         KrateSource {
             version: version.into(),
             name: name.into(),
@@ -33,19 +33,24 @@ impl KrateSource {
             "https://crates.io/api/v1/crates/{}/{}/download",
             self.name, self.version
         );
-        print!("Downloading {}, {}", self.name, self.version);
+        println!("Downloading {}, {} / {}", self.name, self.version, url);
+        std::fs::create_dir("target/crater/").unwrap();
 
-        let krate_name = format!("{}-{}.crate", &self.name, &self.version);
+        std::fs::create_dir(&krate_download_dir).unwrap();
+        std::fs::create_dir(&extract_dir).unwrap();
+
+        let krate_name = format!("{}-{}.crate.tar.gz", &self.name, &self.version);
         let mut krate_dest = std::fs::File::create(krate_download_dir.join(krate_name)).unwrap();
         let mut krate_req = ureq::get(&url).call().unwrap().into_reader();
         std::io::copy(&mut krate_req, &mut krate_dest).unwrap();
-
-        // extract
         let krate = krate_dest;
-        let tar = flate2::read::GzDecoder::new(krate);
+        dbg!(&krate);
+        let tar = flate2::read::GzDecoder::new(&krate);
         let mut archiv = tar::Archive::new(tar);
-        let extracted_path = extract_dir.join(format!("{}-{}/", self.name, self.version));
+        let extracted_path = extract_dir.join(format!("{}-{}", self.name, self.version));
+      // println!("ar:  p: {:?}", &krate, extracted_path);
         archiv.unpack(&extracted_path).expect("Failed to extract!");
+        // extract
 
         Krate {
             version: self.version.clone(),
@@ -71,20 +76,23 @@ fn build_clippy() {
 // the main fn
 pub fn run() {
     let cargo_clippy_path: PathBuf = PathBuf::from("target/debug/cargo-clippy");
-    let clippy_driver_path: PathBuf = PathBuf::from("target/debug/cargo-driver");
+    let clippy_driver_path: PathBuf = PathBuf::from("target/debug/clippy-driver");
 
     // crates we want to check:
     let krates: Vec<KrateSource> = vec![KrateSource::new("cargo", "0.49.0"), KrateSource::new("regex", "1.4.2")];
 
+    println!("Compiling clippy...");
     build_clippy();
+    println!("Done compiling");
+
     // assert that clippy is found
     assert!(
         cargo_clippy_path.is_file(),
-        "target/debug/cargo-clippy binary not found!"
+        "target/debug/cargo-clippy binary not found! {}", cargo_clippy_path.display()
     );
     assert!(
         clippy_driver_path.is_file(),
-        "target/debug/clippy-driver binary not found!"
+        "target/debug/clippy-driver binary not found! {}", clippy_driver_path.display()
     );
 
     // download and extract the crates, then run clippy on them and collect clippys warnings

From e69147486ecf0335176fedfca4914a6161436293 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= <matthias.krueger@famsik.de>
Date: Fri, 18 Dec 2020 16:53:18 +0100
Subject: [PATCH 077/108] cargo clippy dev: fix extraction of downloaded crates

---
 clippy_dev/src/crater.rs | 34 +++++++++++++++++++---------------
 1 file changed, 19 insertions(+), 15 deletions(-)

diff --git a/clippy_dev/src/crater.rs b/clippy_dev/src/crater.rs
index cade6c38bc15d..b18c4edc23663 100644
--- a/clippy_dev/src/crater.rs
+++ b/clippy_dev/src/crater.rs
@@ -34,28 +34,30 @@ impl KrateSource {
             self.name, self.version
         );
         println!("Downloading {}, {} / {}", self.name, self.version, url);
-        std::fs::create_dir("target/crater/").unwrap();
+        let _ = std::fs::create_dir("target/crater/");
 
-        std::fs::create_dir(&krate_download_dir).unwrap();
-        std::fs::create_dir(&extract_dir).unwrap();
+        let _ = std::fs::create_dir(&krate_download_dir);
+        let _ = std::fs::create_dir(&extract_dir);
 
         let krate_name = format!("{}-{}.crate.tar.gz", &self.name, &self.version);
-        let mut krate_dest = std::fs::File::create(krate_download_dir.join(krate_name)).unwrap();
+        let krate_file_path = krate_download_dir.join(krate_name);
+        let mut krate_dest = std::fs::File::create(&krate_file_path).unwrap();
         let mut krate_req = ureq::get(&url).call().unwrap().into_reader();
         std::io::copy(&mut krate_req, &mut krate_dest).unwrap();
-        let krate = krate_dest;
-        dbg!(&krate);
-        let tar = flate2::read::GzDecoder::new(&krate);
-        let mut archiv = tar::Archive::new(tar);
-        let extracted_path = extract_dir.join(format!("{}-{}", self.name, self.version));
-      // println!("ar:  p: {:?}", &krate, extracted_path);
-        archiv.unpack(&extracted_path).expect("Failed to extract!");
-        // extract
+        // unzip the tarball
+        let dl = std::fs::File::open(krate_file_path).unwrap();
+
+        let ungz_tar = flate2::read::GzDecoder::new(dl);
+        // extract the tar archive
+        let mut archiv = tar::Archive::new(ungz_tar);
+        let extract_path = extract_dir.join(format!("{}-{}/", self.name, self.version));
+        archiv.unpack(&extract_path).expect("Failed to extract!");
+        // extracted
 
         Krate {
             version: self.version.clone(),
             name: self.name.clone(),
-            path: extracted_path,
+            path: extract_path,
         }
     }
 }
@@ -88,11 +90,13 @@ pub fn run() {
     // assert that clippy is found
     assert!(
         cargo_clippy_path.is_file(),
-        "target/debug/cargo-clippy binary not found! {}", cargo_clippy_path.display()
+        "target/debug/cargo-clippy binary not found! {}",
+        cargo_clippy_path.display()
     );
     assert!(
         clippy_driver_path.is_file(),
-        "target/debug/clippy-driver binary not found! {}", clippy_driver_path.display()
+        "target/debug/clippy-driver binary not found! {}",
+        clippy_driver_path.display()
     );
 
     // download and extract the crates, then run clippy on them and collect clippys warnings

From 69c0757334806f0cd0bf680428959723b042555b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= <matthias.krueger@famsik.de>
Date: Fri, 18 Dec 2020 17:25:07 +0100
Subject: [PATCH 078/108] clippy cargo dev: fix checking of crates

---
 clippy_dev/src/crater.rs | 25 +++++++++++++++++--------
 1 file changed, 17 insertions(+), 8 deletions(-)

diff --git a/clippy_dev/src/crater.rs b/clippy_dev/src/crater.rs
index b18c4edc23663..d7ed95dfe8641 100644
--- a/clippy_dev/src/crater.rs
+++ b/clippy_dev/src/crater.rs
@@ -50,21 +50,30 @@ impl KrateSource {
         let ungz_tar = flate2::read::GzDecoder::new(dl);
         // extract the tar archive
         let mut archiv = tar::Archive::new(ungz_tar);
-        let extract_path = extract_dir.join(format!("{}-{}/", self.name, self.version));
+        let extract_path = extract_dir.clone();
         archiv.unpack(&extract_path).expect("Failed to extract!");
         // extracted
-
+        dbg!(&extract_path);
         Krate {
             version: self.version.clone(),
             name: self.name.clone(),
-            path: extract_path,
+            path: extract_dir.join(format!("{}-{}/", self.name, self.version))
         }
     }
 }
 
 impl Krate {
-    fn run_clippy_lints(&self) -> String {
-        todo!();
+    fn run_clippy_lints(&self, cargo_clippy_path:  &PathBuf) -> String {
+        let cargo_clippy_path = std::fs::canonicalize(cargo_clippy_path).unwrap();
+        let project_root = &self.path;
+        dbg!(&cargo_clippy_path);
+        dbg!(&project_root);
+
+        let output = std::process::Command::new(cargo_clippy_path).current_dir(project_root).output();
+        dbg!(&output);
+        let output = String::from_utf8_lossy(&output.unwrap().stderr).into_owned();
+        dbg!(&output);
+        output
     }
 }
 
@@ -81,7 +90,7 @@ pub fn run() {
     let clippy_driver_path: PathBuf = PathBuf::from("target/debug/clippy-driver");
 
     // crates we want to check:
-    let krates: Vec<KrateSource> = vec![KrateSource::new("cargo", "0.49.0"), KrateSource::new("regex", "1.4.2")];
+    let krates: Vec<KrateSource> = vec![KrateSource::new("regex", "1.4.2"), KrateSource::new("cargo", "0.49.0"), ];
 
     println!("Compiling clippy...");
     build_clippy();
@@ -97,12 +106,12 @@ pub fn run() {
         clippy_driver_path.is_file(),
         "target/debug/clippy-driver binary not found! {}",
         clippy_driver_path.display()
-    );
+     );
 
     // download and extract the crates, then run clippy on them and collect clippys warnings
     let _clippy_lint_results: Vec<String> = krates
         .into_iter()
         .map(|krate| krate.download_and_extract())
-        .map(|krate| krate.run_clippy_lints())
+        .map(|krate| krate.run_clippy_lints(&cargo_clippy_path))
         .collect::<Vec<String>>();
 }

From 2360a7cad05242ae161a6903d03085c57aa1a099 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= <matthias.krueger@famsik.de>
Date: Fri, 18 Dec 2020 18:01:45 +0100
Subject: [PATCH 079/108] cargo clippy dev: collecting one-line clippy warnings
 works now

---
 clippy_dev/src/crater.rs | 23 ++++++++++++++---------
 1 file changed, 14 insertions(+), 9 deletions(-)

diff --git a/clippy_dev/src/crater.rs b/clippy_dev/src/crater.rs
index d7ed95dfe8641..3ac62f7ebc760 100644
--- a/clippy_dev/src/crater.rs
+++ b/clippy_dev/src/crater.rs
@@ -57,22 +57,26 @@ impl KrateSource {
         Krate {
             version: self.version.clone(),
             name: self.name.clone(),
-            path: extract_dir.join(format!("{}-{}/", self.name, self.version))
+            path: extract_dir.join(format!("{}-{}/", self.name, self.version)),
         }
     }
 }
 
 impl Krate {
-    fn run_clippy_lints(&self, cargo_clippy_path:  &PathBuf) -> String {
+    fn run_clippy_lints(&self, cargo_clippy_path: &PathBuf) -> String {
         let cargo_clippy_path = std::fs::canonicalize(cargo_clippy_path).unwrap();
         let project_root = &self.path;
         dbg!(&cargo_clippy_path);
         dbg!(&project_root);
 
-        let output = std::process::Command::new(cargo_clippy_path).current_dir(project_root).output();
-        dbg!(&output);
-        let output = String::from_utf8_lossy(&output.unwrap().stderr).into_owned();
-        dbg!(&output);
+        let output = std::process::Command::new(cargo_clippy_path)
+            .args(&["--", "--message-format=short","--", "--cap-lints=warn",])
+            .current_dir(project_root)
+            .output();
+        let output: String = String::from_utf8_lossy(&output.unwrap().stderr).lines().filter(|line|line.contains(": warning: ")).collect();
+       // output.lines().for_each(|l| println!("{}", l));
+        //dbg!(&output);
+
         output
     }
 }
@@ -90,7 +94,7 @@ pub fn run() {
     let clippy_driver_path: PathBuf = PathBuf::from("target/debug/clippy-driver");
 
     // crates we want to check:
-    let krates: Vec<KrateSource> = vec![KrateSource::new("regex", "1.4.2"), KrateSource::new("cargo", "0.49.0"), ];
+    let krates: Vec<KrateSource> = vec![KrateSource::new("regex", "1.4.2"), KrateSource::new("cargo", "0.49.0")];
 
     println!("Compiling clippy...");
     build_clippy();
@@ -106,12 +110,13 @@ pub fn run() {
         clippy_driver_path.is_file(),
         "target/debug/clippy-driver binary not found! {}",
         clippy_driver_path.display()
-     );
+    );
 
     // download and extract the crates, then run clippy on them and collect clippys warnings
-    let _clippy_lint_results: Vec<String> = krates
+    let clippy_lint_results: Vec<String> = krates
         .into_iter()
         .map(|krate| krate.download_and_extract())
         .map(|krate| krate.run_clippy_lints(&cargo_clippy_path))
         .collect::<Vec<String>>();
+        dbg!(clippy_lint_results);
 }

From 734d2052df123db0ed0ff05a7ab0f0d9271d18c5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= <matthias.krueger@famsik.de>
Date: Fri, 18 Dec 2020 18:34:09 +0100
Subject: [PATCH 080/108] print all clippy warnings in the end

---
 clippy_dev/src/crater.rs | 29 +++++++++++++++++++----------
 1 file changed, 19 insertions(+), 10 deletions(-)

diff --git a/clippy_dev/src/crater.rs b/clippy_dev/src/crater.rs
index 3ac62f7ebc760..6b121a79e37f3 100644
--- a/clippy_dev/src/crater.rs
+++ b/clippy_dev/src/crater.rs
@@ -63,20 +63,26 @@ impl KrateSource {
 }
 
 impl Krate {
-    fn run_clippy_lints(&self, cargo_clippy_path: &PathBuf) -> String {
+    fn run_clippy_lints(&self, cargo_clippy_path: &PathBuf) -> Vec<String> {
         let cargo_clippy_path = std::fs::canonicalize(cargo_clippy_path).unwrap();
         let project_root = &self.path;
         dbg!(&cargo_clippy_path);
         dbg!(&project_root);
 
         let output = std::process::Command::new(cargo_clippy_path)
-            .args(&["--", "--message-format=short","--", "--cap-lints=warn",])
+            .args(&["--", "--message-format=short", "--", "--cap-lints=warn"])
             .current_dir(project_root)
-            .output();
-        let output: String = String::from_utf8_lossy(&output.unwrap().stderr).lines().filter(|line|line.contains(": warning: ")).collect();
-       // output.lines().for_each(|l| println!("{}", l));
-        //dbg!(&output);
-
+            .output()
+            .unwrap();
+        let mut output = String::from_utf8_lossy(&output.stderr);
+        let output: Vec<&str> = output.lines().collect();
+        let mut output: Vec<String> = output
+            .into_iter()
+            .filter(|line| line.contains(": warning: "))
+            .map(|l| l.to_string())
+            .collect();
+
+        output.sort();
         output
     }
 }
@@ -113,10 +119,13 @@ pub fn run() {
     );
 
     // download and extract the crates, then run clippy on them and collect clippys warnings
-    let clippy_lint_results: Vec<String> = krates
+    let clippy_lint_results: Vec<Vec<String>> = krates
         .into_iter()
         .map(|krate| krate.download_and_extract())
         .map(|krate| krate.run_clippy_lints(&cargo_clippy_path))
-        .collect::<Vec<String>>();
-        dbg!(clippy_lint_results);
+        .collect();
+
+    let results: Vec<String> = clippy_lint_results.into_iter().flatten().collect();
+
+    results.iter().for_each(|l| println!("{}", l));
 }

From 73141337223bfa55d03f2d1097af6a036a6cbbc5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= <matthias.krueger@famsik.de>
Date: Fri, 18 Dec 2020 20:58:46 +0100
Subject: [PATCH 081/108] cargo dev crater: cleanup, don't re-download and
 reextract crates on every run

---
 clippy_dev/src/crater.rs | 88 ++++++++++++++++++++++++----------------
 1 file changed, 52 insertions(+), 36 deletions(-)

diff --git a/clippy_dev/src/crater.rs b/clippy_dev/src/crater.rs
index 6b121a79e37f3..63c04f9a1f196 100644
--- a/clippy_dev/src/crater.rs
+++ b/clippy_dev/src/crater.rs
@@ -13,6 +13,7 @@ struct KrateSource {
 struct Krate {
     version: String,
     name: String,
+    // path to the extracted sources that clippy can check
     path: PathBuf,
 }
 
@@ -23,37 +24,44 @@ impl KrateSource {
             name: name.into(),
         }
     }
+
     fn download_and_extract(&self) -> Krate {
         let extract_dir = PathBuf::from("target/crater/crates");
-
-        // download
         let krate_download_dir = PathBuf::from("target/crater/downloads");
 
+        // url to download the crate from crates.io
         let url = format!(
             "https://crates.io/api/v1/crates/{}/{}/download",
             self.name, self.version
         );
-        println!("Downloading {}, {} / {}", self.name, self.version, url);
+        println!("Downloading and extracting {} {} from {}", self.name, self.version, url);
         let _ = std::fs::create_dir("target/crater/");
-
         let _ = std::fs::create_dir(&krate_download_dir);
         let _ = std::fs::create_dir(&extract_dir);
 
-        let krate_name = format!("{}-{}.crate.tar.gz", &self.name, &self.version);
-        let krate_file_path = krate_download_dir.join(krate_name);
-        let mut krate_dest = std::fs::File::create(&krate_file_path).unwrap();
-        let mut krate_req = ureq::get(&url).call().unwrap().into_reader();
-        std::io::copy(&mut krate_req, &mut krate_dest).unwrap();
-        // unzip the tarball
-        let dl = std::fs::File::open(krate_file_path).unwrap();
-
-        let ungz_tar = flate2::read::GzDecoder::new(dl);
-        // extract the tar archive
-        let mut archiv = tar::Archive::new(ungz_tar);
-        let extract_path = extract_dir.clone();
-        archiv.unpack(&extract_path).expect("Failed to extract!");
-        // extracted
-        dbg!(&extract_path);
+        let krate_file_path = krate_download_dir.join(format!("{}-{}.crate.tar.gz", &self.name, &self.version));
+        // don't download/extract if we already have done so
+        if !krate_file_path.is_file() {
+            // create a file path to download and write the crate data into
+            let mut krate_dest = std::fs::File::create(&krate_file_path).unwrap();
+            let mut krate_req = ureq::get(&url).call().unwrap().into_reader();
+            // copy the crate into the file
+            std::io::copy(&mut krate_req, &mut krate_dest).unwrap();
+
+            // unzip the tarball
+            let ungz_tar = flate2::read::GzDecoder::new(std::fs::File::open(&krate_file_path).unwrap());
+            // extract the tar archive
+            let mut archiv = tar::Archive::new(ungz_tar);
+            archiv.unpack(&extract_dir).expect("Failed to extract!");
+
+            // unzip the tarball
+            let ungz_tar = flate2::read::GzDecoder::new(std::fs::File::open(&krate_file_path).unwrap());
+            // extract the tar archive
+            let mut archiv = tar::Archive::new(ungz_tar);
+            archiv.unpack(&extract_dir).expect("Failed to extract!");
+        }
+        // crate is extracted, return a new Krate object which contains the path to the extracted
+        // sources that clippy can check
         Krate {
             version: self.version.clone(),
             name: self.name.clone(),
@@ -64,24 +72,37 @@ impl KrateSource {
 
 impl Krate {
     fn run_clippy_lints(&self, cargo_clippy_path: &PathBuf) -> Vec<String> {
+        println!("Linting {} {}...", &self.name, &self.version);
         let cargo_clippy_path = std::fs::canonicalize(cargo_clippy_path).unwrap();
-        let project_root = &self.path;
-        dbg!(&cargo_clippy_path);
-        dbg!(&project_root);
 
-        let output = std::process::Command::new(cargo_clippy_path)
+        let all_output = std::process::Command::new(cargo_clippy_path)
+            // lint warnings will look like this:
+            // src/cargo/ops/cargo_compile.rs:127:35: warning: usage of `FromIterator::from_iter`
             .args(&["--", "--message-format=short", "--", "--cap-lints=warn"])
-            .current_dir(project_root)
+            .current_dir(&self.path)
             .output()
             .unwrap();
-        let mut output = String::from_utf8_lossy(&output.stderr);
-        let output: Vec<&str> = output.lines().collect();
-        let mut output: Vec<String> = output
+        let stderr = String::from_utf8_lossy(&all_output.stderr);
+        let output_lines = stderr.lines();
+        let mut output: Vec<String> = output_lines
             .into_iter()
             .filter(|line| line.contains(": warning: "))
-            .map(|l| l.to_string())
+            // prefix with the crate name and version
+            // cargo-0.49.0/src/cargo/ops/cargo_compile.rs:127:35: warning: usage of `FromIterator::from_iter`
+            .map(|line| format!("{}-{}/{}", self.name, self.version, line))
+            // remove the "warning: "
+            .map(|line| {
+                let remove_pat = "warning: ";
+                let pos = line
+                    .find(&remove_pat)
+                    .expect("clippy output did not contain \"warning: \"");
+                let mut new = line[0..pos].to_string();
+                new.push_str(&line[pos + remove_pat.len()..]);
+                new
+            })
             .collect();
 
+        // sort messages alphabtically to avoid noise in the logs
         output.sort();
         output
     }
@@ -97,7 +118,6 @@ fn build_clippy() {
 // the main fn
 pub fn run() {
     let cargo_clippy_path: PathBuf = PathBuf::from("target/debug/cargo-clippy");
-    let clippy_driver_path: PathBuf = PathBuf::from("target/debug/clippy-driver");
 
     // crates we want to check:
     let krates: Vec<KrateSource> = vec![KrateSource::new("regex", "1.4.2"), KrateSource::new("cargo", "0.49.0")];
@@ -112,11 +132,6 @@ pub fn run() {
         "target/debug/cargo-clippy binary not found! {}",
         cargo_clippy_path.display()
     );
-    assert!(
-        clippy_driver_path.is_file(),
-        "target/debug/clippy-driver binary not found! {}",
-        clippy_driver_path.display()
-    );
 
     // download and extract the crates, then run clippy on them and collect clippys warnings
     let clippy_lint_results: Vec<Vec<String>> = krates
@@ -125,7 +140,8 @@ pub fn run() {
         .map(|krate| krate.run_clippy_lints(&cargo_clippy_path))
         .collect();
 
-    let results: Vec<String> = clippy_lint_results.into_iter().flatten().collect();
+    let all_warnings: Vec<String> = clippy_lint_results.into_iter().flatten().collect();
 
-    results.iter().for_each(|l| println!("{}", l));
+    // TODO: save these into a file
+    all_warnings.iter().for_each(|l| println!("{}", l));
 }

From dbb8c0020e76e448f96b1b346dab5afd0d08ce40 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= <matthias.krueger@famsik.de>
Date: Fri, 18 Dec 2020 21:26:41 +0100
Subject: [PATCH 082/108] cargo dev crater: save all warnings into a file

---
 clippy_dev/src/crater.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/clippy_dev/src/crater.rs b/clippy_dev/src/crater.rs
index 63c04f9a1f196..3fb130cc594ca 100644
--- a/clippy_dev/src/crater.rs
+++ b/clippy_dev/src/crater.rs
@@ -98,6 +98,7 @@ impl Krate {
                     .expect("clippy output did not contain \"warning: \"");
                 let mut new = line[0..pos].to_string();
                 new.push_str(&line[pos + remove_pat.len()..]);
+                new.push('\n');
                 new
             })
             .collect();
@@ -142,6 +143,7 @@ pub fn run() {
 
     let all_warnings: Vec<String> = clippy_lint_results.into_iter().flatten().collect();
 
-    // TODO: save these into a file
-    all_warnings.iter().for_each(|l| println!("{}", l));
+    // save the text into mini-crater/logs.txt
+    let text = all_warnings.join("");
+    std::fs::write("mini-crater/logs.txt", text).unwrap();
 }

From 728dc06d88fe276c1368b2c5d99cb3b4df49171c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= <matthias.krueger@famsik.de>
Date: Fri, 18 Dec 2020 21:27:17 +0100
Subject: [PATCH 083/108] add the log file

---
 mini-crater/logs.txt | 180 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 180 insertions(+)
 create mode 100644 mini-crater/logs.txt

diff --git a/mini-crater/logs.txt b/mini-crater/logs.txt
new file mode 100644
index 0000000000000..48296dbd479d4
--- /dev/null
+++ b/mini-crater/logs.txt
@@ -0,0 +1,180 @@
+regex-1.4.2/src/backtrack.rs:100:13: redundant field names in struct initialization
+regex-1.4.2/src/backtrack.rs:133:17: it looks like the same item is being pushed into this Vec
+regex-1.4.2/src/backtrack.rs:223:29: redundant field names in struct initialization
+regex-1.4.2/src/backtrack.rs:230:66: redundant field names in struct initialization
+regex-1.4.2/src/backtrack.rs:97:13: redundant field names in struct initialization
+regex-1.4.2/src/backtrack.rs:98:13: redundant field names in struct initialization
+regex-1.4.2/src/backtrack.rs:99:13: redundant field names in struct initialization
+regex-1.4.2/src/compile.rs:1000:17: redundant field names in struct initialization
+regex-1.4.2/src/compile.rs:1089:44: redundant field names in struct initialization
+regex-1.4.2/src/compile.rs:1089:54: redundant field names in struct initialization
+regex-1.4.2/src/compile.rs:136:46: use of `unwrap_or` followed by a function call
+regex-1.4.2/src/compile.rs:172:42: use of `unwrap_or` followed by a function call
+regex-1.4.2/src/compile.rs:180:43: use of `unwrap_or` followed by a function call
+regex-1.4.2/src/compile.rs:188:5: this function's return value is unnecessarily wrapped by `Result`
+regex-1.4.2/src/compile.rs:375:39: use of `unwrap_or` followed by a function call
+regex-1.4.2/src/compile.rs:379:29: redundant field names in struct initialization
+regex-1.4.2/src/compile.rs:379:41: redundant field names in struct initialization
+regex-1.4.2/src/compile.rs:413:56: redundant field names in struct initialization
+regex-1.4.2/src/compile.rs:421:45: redundant field names in struct initialization
+regex-1.4.2/src/compile.rs:428:51: redundant field names in struct initialization
+regex-1.4.2/src/compile.rs:430:29: redundant field names in struct initialization
+regex-1.4.2/src/compile.rs:438:5: this function's return value is unnecessarily wrapped by `Result`
+regex-1.4.2/src/compile.rs:43:5: you should consider adding a `Default` implementation for `compile::Compiler`
+regex-1.4.2/src/compile.rs:468:5: this function's return value is unnecessarily wrapped by `Result`
+regex-1.4.2/src/compile.rs:469:57: redundant field names in struct initialization
+regex-1.4.2/src/compile.rs:470:25: redundant field names in struct initialization
+regex-1.4.2/src/compile.rs:494:25: redundant field names in struct initialization
+regex-1.4.2/src/compile.rs:494:37: redundant field names in struct initialization
+regex-1.4.2/src/compile.rs:637:14: use of `unwrap_or` followed by a function call
+regex-1.4.2/src/compile.rs:661:41: use of `unwrap_or` followed by a function call
+regex-1.4.2/src/compile.rs:786:5: this function's return value is unnecessarily wrapped by `Result`
+regex-1.4.2/src/compile.rs:838:21: redundant field names in struct initialization
+regex-1.4.2/src/compile.rs:845:21: redundant field names in struct initialization
+regex-1.4.2/src/compile.rs:860:41: redundant field names in struct initialization
+regex-1.4.2/src/compile.rs:860:55: redundant field names in struct initialization
+regex-1.4.2/src/compile.rs:920:39: redundant field names in struct initialization
+regex-1.4.2/src/compile.rs:920:51: redundant field names in struct initialization
+regex-1.4.2/src/compile.rs:923:49: redundant field names in struct initialization
+regex-1.4.2/src/compile.rs:923:61: redundant field names in struct initialization
+regex-1.4.2/src/compile.rs:925:59: redundant field names in struct initialization
+regex-1.4.2/src/compile.rs:925:71: redundant field names in struct initialization
+regex-1.4.2/src/compile.rs:927:43: redundant field names in struct initialization
+regex-1.4.2/src/compile.rs:930:41: redundant field names in struct initialization
+regex-1.4.2/src/compile.rs:930:53: redundant field names in struct initialization
+regex-1.4.2/src/compile.rs:930:67: redundant field names in struct initialization
+regex-1.4.2/src/compile.rs:991:5: this function's return value is unnecessarily wrapped by `Result`
+regex-1.4.2/src/dfa.rs:1380:14: the operation is ineffective. Consider reducing it to `(empty_flags.start as u8)`
+regex-1.4.2/src/dfa.rs:1614:13: redundant field names in struct initialization
+regex-1.4.2/src/dfa.rs:1651:38: redundant field names in struct initialization
+regex-1.4.2/src/dfa.rs:1701:18: digits of hex or binary literal not grouped by four
+regex-1.4.2/src/dfa.rs:1705:19: digits of hex or binary literal not grouped by four
+regex-1.4.2/src/dfa.rs:1709:18: digits of hex or binary literal not grouped by four
+regex-1.4.2/src/dfa.rs:1713:19: digits of hex or binary literal not grouped by four
+regex-1.4.2/src/dfa.rs:1717:18: digits of hex or binary literal not grouped by four
+regex-1.4.2/src/dfa.rs:1721:19: digits of hex or binary literal not grouped by four
+regex-1.4.2/src/dfa.rs:1741:9: match expression looks like `matches!` macro
+regex-1.4.2/src/dfa.rs:457:13: redundant field names in struct initialization
+regex-1.4.2/src/dfa.rs:459:13: redundant field names in struct initialization
+regex-1.4.2/src/dfa.rs:460:13: redundant field names in struct initialization
+regex-1.4.2/src/dfa.rs:487:13: redundant field names in struct initialization
+regex-1.4.2/src/dfa.rs:489:13: redundant field names in struct initialization
+regex-1.4.2/src/dfa.rs:490:13: redundant field names in struct initialization
+regex-1.4.2/src/dfa.rs:518:13: redundant field names in struct initialization
+regex-1.4.2/src/dfa.rs:520:13: redundant field names in struct initialization
+regex-1.4.2/src/error.rs:6:1: this seems like a manual implementation of the non-exhaustive pattern
+regex-1.4.2/src/exec.rs:1028:5: this function has too many arguments (9/7)
+regex-1.4.2/src/exec.rs:137:9: field assignment outside of initializer for an instance created with Default::default()
+regex-1.4.2/src/exec.rs:245:62: this `if` has identical blocks
+regex-1.4.2/src/exec.rs:262:60: this `if` has identical blocks
+regex-1.4.2/src/exec.rs:278:13: redundant field names in struct initialization
+regex-1.4.2/src/exec.rs:281:13: redundant field names in struct initialization
+regex-1.4.2/src/exec.rs:300:30: redundant field names in struct initialization
+regex-1.4.2/src/exec.rs:329:13: redundant field names in struct initialization
+regex-1.4.2/src/exec.rs:330:13: redundant field names in struct initialization
+regex-1.4.2/src/exec.rs:331:13: redundant field names in struct initialization
+regex-1.4.2/src/exec.rs:334:13: redundant field names in struct initialization
+regex-1.4.2/src/exec.rs:340:19: redundant field names in struct initialization
+regex-1.4.2/src/expand.rs:130:22: this call to `as_ref` does nothing
+regex-1.4.2/src/expand.rs:186:5: match expression looks like `matches!` macro
+regex-1.4.2/src/expand.rs:22:13: calling `push_str()` using a single-character string literal
+regex-1.4.2/src/expand.rs:30:17: calling `push_str()` using a single-character string literal
+regex-1.4.2/src/input.rs:165:31: redundant field names in struct initialization
+regex-1.4.2/src/input.rs:236:21: redundant field names in struct initialization
+regex-1.4.2/src/input.rs:236:33: redundant field names in struct initialization
+regex-1.4.2/src/literal/imp.rs:435:13: redundant field names in struct initialization
+regex-1.4.2/src/literal/imp.rs:436:13: redundant field names in struct initialization
+regex-1.4.2/src/literal/imp.rs:437:13: redundant field names in struct initialization
+regex-1.4.2/src/literal/imp.rs:438:13: redundant field names in struct initialization
+regex-1.4.2/src/literal/imp.rs:439:13: redundant field names in struct initialization
+regex-1.4.2/src/literal/imp.rs:440:13: redundant field names in struct initialization
+regex-1.4.2/src/literal/imp.rs:579:13: redundant field names in struct initialization
+regex-1.4.2/src/literal/imp.rs:580:13: redundant field names in struct initialization
+regex-1.4.2/src/literal/imp.rs:583:13: redundant field names in struct initialization
+regex-1.4.2/src/literal/imp.rs:648:9: unneeded `return` statement
+regex-1.4.2/src/literal/imp.rs:65:13: redundant field names in struct initialization
+regex-1.4.2/src/literal/imp.rs:68:13: redundant field names in struct initialization
+regex-1.4.2/src/literal/imp.rs:786:42: manual saturating arithmetic
+regex-1.4.2/src/pikevm.rs:103:15: redundant field names in struct initialization
+regex-1.4.2/src/pikevm.rs:103:52: redundant field names in struct initialization
+regex-1.4.2/src/pikevm.rs:114:5: this function has too many arguments (8/7)
+regex-1.4.2/src/pikevm.rs:224:5: this function has too many arguments (8/7)
+regex-1.4.2/src/pikevm.rs:88:5: this function has too many arguments (8/7)
+regex-1.4.2/src/prog.rs:120:9: match expression looks like `matches!` macro
+regex-1.4.2/src/prog.rs:236:13: using `write!()` with a format string that ends in a single newline
+regex-1.4.2/src/prog.rs:301:9: match expression looks like `matches!` macro
+regex-1.4.2/src/prog.rs:80:5: you should consider adding a `Default` implementation for `prog::Program`
+regex-1.4.2/src/re_bytes.rs:1100:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+regex-1.4.2/src/re_bytes.rs:1125:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+regex-1.4.2/src/re_bytes.rs:1140:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+regex-1.4.2/src/re_bytes.rs:257:13: redundant field names in struct initialization
+regex-1.4.2/src/re_bytes.rs:55:33: redundant field names in struct initialization
+regex-1.4.2/src/re_bytes.rs:55:47: redundant field names in struct initialization
+regex-1.4.2/src/re_bytes.rs:721:13: redundant field names in struct initialization
+regex-1.4.2/src/re_bytes.rs:844:1: item `re_bytes::CaptureLocations` has a public `len` method but no corresponding `is_empty` method
+regex-1.4.2/src/re_bytes.rs:892:1: item `re_bytes::Captures<'t>` has a public `len` method but no corresponding `is_empty` method
+regex-1.4.2/src/re_set.rs:192:13: redundant field names in struct initialization
+regex-1.4.2/src/re_set.rs:192:13: redundant field names in struct initialization
+regex-1.4.2/src/re_trait.rs:137:29: redundant field names in struct initialization
+regex-1.4.2/src/re_unicode.rs:1095:13: redundant field names in struct initialization
+regex-1.4.2/src/re_unicode.rs:1142:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+regex-1.4.2/src/re_unicode.rs:1167:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+regex-1.4.2/src/re_unicode.rs:314:13: redundant field names in struct initialization
+regex-1.4.2/src/re_unicode.rs:64:33: redundant field names in struct initialization
+regex-1.4.2/src/re_unicode.rs:64:47: redundant field names in struct initialization
+regex-1.4.2/src/re_unicode.rs:861:1: item `re_unicode::CaptureLocations` has a public `len` method but no corresponding `is_empty` method
+regex-1.4.2/src/re_unicode.rs:909:1: item `re_unicode::Captures<'t>` has a public `len` method but no corresponding `is_empty` method
+regex-1.4.2/src/utf8.rs:100:16: digits of hex or binary literal not grouped by four
+regex-1.4.2/src/utf8.rs:103:16: digits of hex or binary literal not grouped by four
+regex-1.4.2/src/utf8.rs:143:24: digits of hex or binary literal not grouped by four
+regex-1.4.2/src/utf8.rs:143:9: digits of hex or binary literal not grouped by four
+regex-1.4.2/src/utf8.rs:30:20: digits of hex or binary literal not grouped by four
+regex-1.4.2/src/utf8.rs:58:23: digits of hex or binary literal not grouped by four
+regex-1.4.2/src/utf8.rs:58:9: digits of hex or binary literal not grouped by four
+regex-1.4.2/src/utf8.rs:63:16: digits of hex or binary literal not grouped by four
+regex-1.4.2/src/utf8.rs:77:16: digits of hex or binary literal not grouped by four
+regex-1.4.2/src/utf8.rs:80:16: digits of hex or binary literal not grouped by four
+regex-1.4.2/src/utf8.rs:92:23: digits of hex or binary literal not grouped by four
+regex-1.4.2/src/utf8.rs:92:9: digits of hex or binary literal not grouped by four
+regex-1.4.2/src/utf8.rs:97:16: digits of hex or binary literal not grouped by four
+cargo-0.49.0/src/bin/cargo/cli.rs:121:5: calling `push_str()` using a single-character string literal
+cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:353:56: stripping a prefix manually
+cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:762:5: this function's return value is unnecessarily wrapped by `Result`
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1664:5: field assignment outside of initializer for an instance created with Default::default()
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1795:5: field assignment outside of initializer for an instance created with Default::default()
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1980:24: stripping a prefix manually
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:1131:1: this function's return value is unnecessarily wrapped by `Result`
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:364:5: this function's return value is unnecessarily wrapped by `Result`
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:693:1: this function's return value is unnecessarily wrapped by `Result`
+cargo-0.49.0/src/cargo/core/package.rs:421:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+cargo-0.49.0/src/cargo/core/profiles.rs:143:5: this function's return value is unnecessarily wrapped by `Result`
+cargo-0.49.0/src/cargo/core/profiles.rs:372:9: field assignment outside of initializer for an instance created with Default::default()
+cargo-0.49.0/src/cargo/core/resolver/errors.rs:305:17: calling `push_str()` using a single-character string literal
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:239:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+cargo-0.49.0/src/cargo/core/resolver/types.rs:187:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+cargo-0.49.0/src/cargo/core/resolver/types.rs:261:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+cargo-0.49.0/src/cargo/core/workspace.rs:1056:5: this function's return value is unnecessarily wrapped by `Result`
+cargo-0.49.0/src/cargo/core/workspace.rs:440:9: this function's return value is unnecessarily wrapped by `Result`
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:127:35: usage of `FromIterator::from_iter`
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:233:21: calling `push_str()` using a single-character string literal
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:370:5: this function's return value is unnecessarily wrapped by `Result`
+cargo-0.49.0/src/cargo/ops/fix.rs:608:9: field assignment outside of initializer for an instance created with Default::default()
+cargo-0.49.0/src/cargo/ops/fix.rs:619:48: stripping a prefix manually
+cargo-0.49.0/src/cargo/ops/lockfile.rs:154:13: calling `push_str()` using a single-character string literal
+cargo-0.49.0/src/cargo/ops/lockfile.rs:217:9: calling `push_str()` using a single-character string literal
+cargo-0.49.0/src/cargo/ops/lockfile.rs:87:1: this function's return value is unnecessarily wrapped by `Result`
+cargo-0.49.0/src/cargo/sources/git/source.rs:69:20: comparison to empty slice
+cargo-0.49.0/src/cargo/sources/git/utils.rs:1158:9: stripping a suffix manually
+cargo-0.49.0/src/cargo/sources/git/utils.rs:758:9: calling `push_str()` using a single-character string literal
+cargo-0.49.0/src/cargo/sources/path.rs:339:9: this function's return value is unnecessarily wrapped by `Result`
+cargo-0.49.0/src/cargo/sources/registry/index.rs:736:1: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+cargo-0.49.0/src/cargo/util/config/key.rs:69:9: calling `push_str()` using a single-character string literal
+cargo-0.49.0/src/cargo/util/config/value.rs:81:9: match expression looks like `matches!` macro
+cargo-0.49.0/src/cargo/util/errors.rs:473:5: manual `RangeInclusive::contains` implementation
+cargo-0.49.0/src/cargo/util/paths.rs:93:31: comparison to empty slice
+cargo-0.49.0/src/cargo/util/progress.rs:269:17: calling `push_str()` using a single-character string literal
+cargo-0.49.0/src/cargo/util/progress.rs:272:17: calling `push_str()` using a single-character string literal
+cargo-0.49.0/src/cargo/util/progress.rs:274:17: calling `push_str()` using a single-character string literal
+cargo-0.49.0/src/cargo/util/progress.rs:280:13: calling `push_str()` using a single-character string literal
+cargo-0.49.0/src/cargo/util/progress.rs:282:9: calling `push_str()` using a single-character string literal
+cargo-0.49.0/src/cargo/util/toml/mod.rs:1687:33: unnecessary closure used to substitute value for `Option::None`

From 1e5ac1dfd215f554c5b7980c21fb7eda5f4c526e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= <matthias.krueger@famsik.de>
Date: Fri, 18 Dec 2020 21:50:06 +0100
Subject: [PATCH 084/108] cargo dev crater: add more crates to be checked

---
 clippy_dev/src/crater.rs |  34 ++++-
 mini-crater/logs.txt     | 290 +++++++++++++++++++++++++++++++++------
 2 files changed, 281 insertions(+), 43 deletions(-)

diff --git a/clippy_dev/src/crater.rs b/clippy_dev/src/crater.rs
index 3fb130cc594ca..b23d9b4d9879c 100644
--- a/clippy_dev/src/crater.rs
+++ b/clippy_dev/src/crater.rs
@@ -78,7 +78,16 @@ impl Krate {
         let all_output = std::process::Command::new(cargo_clippy_path)
             // lint warnings will look like this:
             // src/cargo/ops/cargo_compile.rs:127:35: warning: usage of `FromIterator::from_iter`
-            .args(&["--", "--message-format=short", "--", "--cap-lints=warn"])
+            .args(&[
+                "--",
+                "--message-format=short",
+                "--",
+                "--cap-lints=warn",
+            /*    "--",
+                "-Wclippy::pedantic",
+                "--",
+                "-Wclippy::cargo", */
+            ])
             .current_dir(&self.path)
             .output()
             .unwrap();
@@ -121,7 +130,28 @@ pub fn run() {
     let cargo_clippy_path: PathBuf = PathBuf::from("target/debug/cargo-clippy");
 
     // crates we want to check:
-    let krates: Vec<KrateSource> = vec![KrateSource::new("regex", "1.4.2"), KrateSource::new("cargo", "0.49.0")];
+    let krates: Vec<KrateSource> = vec![
+        // some of these are form cargotest
+        KrateSource::new("cargo", "0.49.0"),
+        KrateSource::new("iron", "0.6.1"),
+        KrateSource::new("ripgrep", "12.1.1"),
+        KrateSource::new("tokei", "12.0.4"),
+        KrateSource::new("xsv", "0.13.0"),
+        KrateSource::new("serde", "1.0.118"),
+        KrateSource::new("rayon", "1.5.0"),
+        // top 10 crates.io dls
+        KrateSource::new("rand", "0.7.3"),
+        KrateSource::new("syn", "1.0.54"),
+        KrateSource::new("libc", "0.2.81"),
+        KrateSource::new("quote", "1.0.7"),
+        KrateSource::new("rand_core", "0.6.0"),
+        KrateSource::new("unicode-xid", "0.2.1"),
+        KrateSource::new("proc-macro2", "1.0.24"),
+        KrateSource::new("bitflags", "1.2.1"),
+        KrateSource::new("log", "0.4.11"),
+        KrateSource::new("regex", "1.4.2")
+        //
+    ];
 
     println!("Compiling clippy...");
     build_clippy();
diff --git a/mini-crater/logs.txt b/mini-crater/logs.txt
index 48296dbd479d4..b32d9f30d42dd 100644
--- a/mini-crater/logs.txt
+++ b/mini-crater/logs.txt
@@ -1,3 +1,252 @@
+cargo-0.49.0/src/bin/cargo/cli.rs:121:5: calling `push_str()` using a single-character string literal
+cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:353:56: stripping a prefix manually
+cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:762:5: this function's return value is unnecessarily wrapped by `Result`
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1664:5: field assignment outside of initializer for an instance created with Default::default()
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1795:5: field assignment outside of initializer for an instance created with Default::default()
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1980:24: stripping a prefix manually
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:1131:1: this function's return value is unnecessarily wrapped by `Result`
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:364:5: this function's return value is unnecessarily wrapped by `Result`
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:693:1: this function's return value is unnecessarily wrapped by `Result`
+cargo-0.49.0/src/cargo/core/package.rs:421:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+cargo-0.49.0/src/cargo/core/profiles.rs:143:5: this function's return value is unnecessarily wrapped by `Result`
+cargo-0.49.0/src/cargo/core/profiles.rs:372:9: field assignment outside of initializer for an instance created with Default::default()
+cargo-0.49.0/src/cargo/core/resolver/errors.rs:305:17: calling `push_str()` using a single-character string literal
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:239:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+cargo-0.49.0/src/cargo/core/resolver/types.rs:187:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+cargo-0.49.0/src/cargo/core/resolver/types.rs:261:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+cargo-0.49.0/src/cargo/core/workspace.rs:1056:5: this function's return value is unnecessarily wrapped by `Result`
+cargo-0.49.0/src/cargo/core/workspace.rs:440:9: this function's return value is unnecessarily wrapped by `Result`
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:127:35: usage of `FromIterator::from_iter`
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:233:21: calling `push_str()` using a single-character string literal
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:370:5: this function's return value is unnecessarily wrapped by `Result`
+cargo-0.49.0/src/cargo/ops/fix.rs:608:9: field assignment outside of initializer for an instance created with Default::default()
+cargo-0.49.0/src/cargo/ops/fix.rs:619:48: stripping a prefix manually
+cargo-0.49.0/src/cargo/ops/lockfile.rs:154:13: calling `push_str()` using a single-character string literal
+cargo-0.49.0/src/cargo/ops/lockfile.rs:217:9: calling `push_str()` using a single-character string literal
+cargo-0.49.0/src/cargo/ops/lockfile.rs:87:1: this function's return value is unnecessarily wrapped by `Result`
+cargo-0.49.0/src/cargo/sources/git/source.rs:69:20: comparison to empty slice
+cargo-0.49.0/src/cargo/sources/git/utils.rs:1158:9: stripping a suffix manually
+cargo-0.49.0/src/cargo/sources/git/utils.rs:758:9: calling `push_str()` using a single-character string literal
+cargo-0.49.0/src/cargo/sources/path.rs:339:9: this function's return value is unnecessarily wrapped by `Result`
+cargo-0.49.0/src/cargo/sources/registry/index.rs:736:1: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+cargo-0.49.0/src/cargo/util/config/key.rs:69:9: calling `push_str()` using a single-character string literal
+cargo-0.49.0/src/cargo/util/config/value.rs:81:9: match expression looks like `matches!` macro
+cargo-0.49.0/src/cargo/util/errors.rs:473:5: manual `RangeInclusive::contains` implementation
+cargo-0.49.0/src/cargo/util/paths.rs:93:31: comparison to empty slice
+cargo-0.49.0/src/cargo/util/progress.rs:269:17: calling `push_str()` using a single-character string literal
+cargo-0.49.0/src/cargo/util/progress.rs:272:17: calling `push_str()` using a single-character string literal
+cargo-0.49.0/src/cargo/util/progress.rs:274:17: calling `push_str()` using a single-character string literal
+cargo-0.49.0/src/cargo/util/progress.rs:280:13: calling `push_str()` using a single-character string literal
+cargo-0.49.0/src/cargo/util/progress.rs:282:9: calling `push_str()` using a single-character string literal
+cargo-0.49.0/src/cargo/util/toml/mod.rs:1687:33: unnecessary closure used to substitute value for `Option::None`
+iron-0.6.1/src/error.rs:55:20: use of deprecated associated function `std::error::Error::description`: use the Display impl or to_string()
+iron-0.6.1/src/iron.rs:105:13: redundant field names in struct initialization
+iron-0.6.1/src/iron.rs:148:19: use of deprecated macro `try`: use the `?` operator instead
+iron-0.6.1/src/iron.rs:149:13: redundant field names in struct initialization
+iron-0.6.1/src/modifiers.rs:132:14: use of `expect` followed by a function call
+iron-0.6.1/src/request/mod.rs:121:13: redundant field names in struct initialization
+iron-0.6.1/src/request/mod.rs:123:13: redundant field names in struct initialization
+iron-0.6.1/src/request/mod.rs:124:13: redundant field names in struct initialization
+iron-0.6.1/src/request/mod.rs:126:13: redundant field names in struct initialization
+iron-0.6.1/src/request/mod.rs:128:13: redundant field names in struct initialization
+iron-0.6.1/src/request/mod.rs:32:1: this seems like a manual implementation of the non-exhaustive pattern
+iron-0.6.1/src/request/mod.rs:62:9: use of deprecated macro `try`: use the `?` operator instead
+iron-0.6.1/src/request/mod.rs:64:9: use of deprecated macro `try`: use the `?` operator instead
+iron-0.6.1/src/request/mod.rs:65:9: use of deprecated macro `try`: use the `?` operator instead
+iron-0.6.1/src/request/mod.rs:66:9: use of deprecated macro `try`: use the `?` operator instead
+iron-0.6.1/src/request/mod.rs:67:9: use of deprecated macro `try`: use the `?` operator instead
+iron-0.6.1/src/request/mod.rs:69:9: use of deprecated macro `try`: use the `?` operator instead
+iron-0.6.1/src/request/url.rs:124:9: use of deprecated macro `try`: use the `?` operator instead
+iron-0.6.1/src/response.rs:142:23: use of deprecated macro `try`: use the `?` operator instead
+iron-0.6.1/src/response.rs:143:5: use of deprecated macro `try`: use the `?` operator instead
+iron-0.6.1/src/response.rs:95:5: you should consider adding a `Default` implementation for `response::Response`
+ripgrep-12.1.1/build.rs:133:19: called `.as_ref().map(|x| &**x)` on an Option value. This can be done more directly by calling `githash.as_deref()` instead
+ripgrep-12.1.1/build.rs:92:19: called `.as_ref().map(|x| &**x)` on an Option value. This can be done more directly by calling `githash.as_deref()` instead
+ripgrep-12.1.1/crates/core/args.rs:11:1: this import is redundant
+ripgrep-12.1.1/crates/core/args.rs:1209:74: this `if` has identical blocks
+ripgrep-12.1.1/crates/core/args.rs:1209:74: this `if` has identical blocks
+ripgrep-12.1.1/crates/core/args.rs:1524:5: this function's return value is unnecessarily wrapped by `Result`
+ripgrep-12.1.1/crates/core/args.rs:33:1: this import is redundant
+ripgrep-12.1.1/crates/core/args.rs:34:1: this import is redundant
+ripgrep-12.1.1/crates/core/args.rs:35:1: this import is redundant
+ripgrep-12.1.1/crates/core/args.rs:549:16: methods called `to_*` usually take self by reference; consider choosing a less ambiguous name
+ripgrep-12.1.1/crates/core/config.rs:13:1: this import is redundant
+ripgrep-12.1.1/crates/core/config.rs:58:6: very complex type used. Consider factoring parts into `type` definitions
+ripgrep-12.1.1/crates/core/config.rs:79:6: very complex type used. Consider factoring parts into `type` definitions
+ripgrep-12.1.1/crates/core/logger.rs:15:16: constants have by default a `'static` lifetime
+ripgrep-12.1.1/crates/core/search.rs:292:9: using `write!()` with a format string that ends in a single newline
+ripgrep-12.1.1/crates/core/search.rs:377:12: this boolean expression can be simplified
+ripgrep-12.1.1/crates/core/search.rs:472:24: you are using an explicit closure for cloning elements
+ripgrep-12.1.1/crates/core/search.rs:480:24: you are using an explicit closure for cloning elements
+ripgrep-12.1.1/crates/core/search.rs:509:24: you are using an explicit closure for cloning elements
+ripgrep-12.1.1/crates/core/search.rs:517:24: you are using an explicit closure for cloning elements
+ripgrep-12.1.1/crates/core/subject.rs:4:1: this import is redundant
+tokei-12.0.4/src/cli_utils.rs:154:25: this lifetime isn't used in the function definition
+tokei-12.0.4/src/cli_utils.rs:154:29: this lifetime isn't used in the function definition
+tokei-12.0.4/src/cli_utils.rs:195:47: useless use of `format!`
+tokei-12.0.4/src/cli_utils.rs:306:47: useless use of `format!`
+tokei-12.0.4/src/config.rs:102:36: use of `or` followed by a function call
+tokei-12.0.4/src/config.rs:103:38: use of `or` followed by a function call
+tokei-12.0.4/src/config.rs:106:18: use of `or` followed by a function call
+tokei-12.0.4/src/config.rs:109:18: use of `or` followed by a function call
+tokei-12.0.4/src/config.rs:112:18: use of `or` followed by a function call
+tokei-12.0.4/src/config.rs:97:18: use of `or` followed by a function call
+tokei-12.0.4/src/config.rs:99:86: use of `or` followed by a function call
+tokei-12.0.4/src/language/language_type.rs:75:22: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `slice`
+tokei-12.0.4/src/language/syntax.rs:334:45: this `if` has identical blocks
+tokei-12.0.4/src/language/syntax.rs:334:45: this `if` has identical blocks
+tokei-12.0.4/src/language/syntax.rs:336:39: this `if` has identical blocks
+tokei-12.0.4/src/language/syntax.rs:338:16: this if-then-else expression returns a bool literal
+tokei-12.0.4/src/language/syntax.rs:338:43: this `if` has identical blocks
+tokei-12.0.4/src/language/syntax.rs:446:74: trivial regex
+tokei-12.0.4/src/language/syntax.rs:449:73: trivial regex
+tokei-12.0.4/src/language/syntax.rs:453:45: trivial regex
+tokei-12.0.4/src/utils/fs.rs:105:26: called `.as_ref().map(|v| &**v)` on an Option value. This can be done more directly by calling `config.types.as_deref()` instead
+xsv-0.13.0/src/cmd/cat.rs:7:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/count.rs:50:5: passing a unit value to a function
+xsv-0.13.0/src/cmd/count.rs:7:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/fixlengths.rs:9:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/flatten.rs:10:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/fmt.rs:7:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/frequency.rs:15:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/frequency.rs:178:24: this `else { if .. }` block can be collapsed
+xsv-0.13.0/src/cmd/headers.rs:60:22: trait objects without an explicit `dyn` are deprecated
+xsv-0.13.0/src/cmd/headers.rs:9:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/index.rs:11:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/input.rs:7:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/join.rs:17:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/join.rs:281:44: trait objects without an explicit `dyn` are deprecated
+xsv-0.13.0/src/cmd/join.rs:297:13: redundant field names in struct initialization
+xsv-0.13.0/src/cmd/join.rs:298:13: redundant field names in struct initialization
+xsv-0.13.0/src/cmd/join.rs:299:13: redundant field names in struct initialization
+xsv-0.13.0/src/cmd/join.rs:300:13: redundant field names in struct initialization
+xsv-0.13.0/src/cmd/join.rs:392:13: redundant field names in struct initialization
+xsv-0.13.0/src/cmd/partition.rs:126:36: trait objects without an explicit `dyn` are deprecated
+xsv-0.13.0/src/cmd/partition.rs:139:13: redundant field names in struct initialization
+xsv-0.13.0/src/cmd/partition.rs:15:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/sample.rs:11:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/search.rs:9:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/select.rs:8:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/slice.rs:9:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/sort.rs:11:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/split.rs:131:36: trait objects without an explicit `dyn` are deprecated
+xsv-0.13.0/src/cmd/split.rs:14:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/split.rs:94:5: this function's return value is unnecessarily wrapped by `Result`
+xsv-0.13.0/src/cmd/stats.rs:22:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/stats.rs:269:13: redundant field names in struct initialization
+xsv-0.13.0/src/cmd/stats.rs:270:13: redundant field names in struct initialization
+xsv-0.13.0/src/cmd/stats.rs:271:13: redundant field names in struct initialization
+xsv-0.13.0/src/cmd/stats.rs:272:13: redundant field names in struct initialization
+xsv-0.13.0/src/cmd/stats.rs:273:13: redundant field names in struct initialization
+xsv-0.13.0/src/cmd/stats.rs:274:13: redundant field names in struct initialization
+xsv-0.13.0/src/cmd/stats.rs:283:9: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
+xsv-0.13.0/src/cmd/stats.rs:284:9: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
+xsv-0.13.0/src/cmd/stats.rs:285:9: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
+xsv-0.13.0/src/cmd/stats.rs:290:21: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
+xsv-0.13.0/src/cmd/stats.rs:297:25: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
+xsv-0.13.0/src/cmd/stats.rs:301:21: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
+xsv-0.13.0/src/cmd/stats.rs:302:21: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
+xsv-0.13.0/src/cmd/stats.rs:308:18: methods called `to_*` usually take self by reference; consider choosing a less ambiguous name
+xsv-0.13.0/src/cmd/stats.rs:402:16: redundant pattern matching, consider using `is_ok()`
+xsv-0.13.0/src/cmd/stats.rs:403:16: redundant pattern matching, consider using `is_ok()`
+xsv-0.13.0/src/cmd/table.rs:10:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/config.rs:113:43: use of `unwrap_or` followed by a function call
+xsv-0.13.0/src/config.rs:197:48: trait objects without an explicit `dyn` are deprecated
+xsv-0.13.0/src/config.rs:202:48: trait objects without an explicit `dyn` are deprecated
+xsv-0.13.0/src/config.rs:263:47: trait objects without an explicit `dyn` are deprecated
+xsv-0.13.0/src/config.rs:293:47: trait objects without an explicit `dyn` are deprecated
+xsv-0.13.0/src/config.rs:90:13: redundant field names in struct initialization
+xsv-0.13.0/src/index.rs:31:13: redundant field names in struct initialization
+xsv-0.13.0/src/main.rs:164:49: redundant clone
+xsv-0.13.0/src/main.rs:75:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/select.rs:154:5: this function's return value is unnecessarily wrapped by `Result`
+xsv-0.13.0/src/select.rs:280:20: length comparison to zero
+xsv-0.13.0/src/select.rs:29:13: redundant field names in struct initialization
+xsv-0.13.0/src/select.rs:360:9: this function's return value is unnecessarily wrapped by `Option`
+xsv-0.13.0/src/select.rs:375:9: used sort instead of sort_unstable to sort primitive type `usize`
+xsv-0.13.0/src/select.rs:416:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+xsv-0.13.0/src/select.rs:419:9: this function's return value is unnecessarily wrapped by `Option`
+xsv-0.13.0/src/util.rs:190:48: trait objects without an explicit `dyn` are deprecated
+xsv-0.13.0/src/util.rs:37:33: you are using an explicit closure for copying elements
+xsv-0.13.0/src/util.rs:90:1: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+rayon-1.5.0/src/collections/mod.rs:59:32: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
+rayon-1.5.0/src/compile_fail/cannot_collect_filtermap_data.rs:2:1: needless `fn main` in doctest
+rayon-1.5.0/src/compile_fail/cannot_zip_filtered_data.rs:2:1: needless `fn main` in doctest
+rayon-1.5.0/src/compile_fail/cell_par_iter.rs:2:1: needless `fn main` in doctest
+rayon-1.5.0/src/compile_fail/no_send_par_iter.rs:25:1: needless `fn main` in doctest
+rayon-1.5.0/src/compile_fail/no_send_par_iter.rs:46:1: needless `fn main` in doctest
+rayon-1.5.0/src/compile_fail/no_send_par_iter.rs:4:1: needless `fn main` in doctest
+rayon-1.5.0/src/compile_fail/rc_par_iter.rs:2:1: needless `fn main` in doctest
+rayon-1.5.0/src/iter/interleave.rs:313:9: `if` chain can be rewritten with `match`
+rayon-1.5.0/src/iter/mod.rs:2171:1: trait `IndexedParallelIterator` has a `len` method but no (possibly inherited) `is_empty` method
+rayon-1.5.0/src/slice/quicksort.rs:588:17: the operation is ineffective. Consider reducing it to `len / 4`
+rayon-1.5.0/src/str.rs:715:9: stripping a suffix manually
+rayon-1.5.0/src/vec.rs:137:12: length comparison to zero
+rand-0.7.3/src/distributions/bernoulli.rs:96:13: manual `Range::contains` implementation
+rand-0.7.3/src/distributions/uniform.rs:146:4: needless `fn main` in doctest
+rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
+rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
+rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
+rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
+rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
+rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
+rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
+rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
+rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
+rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
+rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
+rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
+rand-0.7.3/src/distributions/weighted/alias_method.rs:259:28: using `clone` on type `distributions::uniform::Uniform<u32>` which implements the `Copy` trait
+rand-0.7.3/src/distributions/weighted/alias_method.rs:296:9: you are using an explicit closure for copying elements
+rand-0.7.3/src/distributions/weighted/alias_method.rs:321:9: you are using an explicit closure for copying elements
+rand-0.7.3/src/distributions/weighted/mod.rs:169:16: unnecessary `>= y + 1` or `x - 1 >=`
+rand-0.7.3/src/seq/index.rs:87:5: method `into_iter` can be confused for the standard trait method `std::iter::IntoIterator::into_iter`
+rand-0.7.3/src/seq/mod.rs:229:4: needless `fn main` in doctest
+rand-0.7.3/src/seq/mod.rs:45:4: needless `fn main` in doctest
+syn-1.0.54/src/lit.rs:1397:40: redundant else block
+syn-1.0.54/src/lit.rs:1405:28: redundant else block
+syn-1.0.54/src/lit.rs:1485:32: redundant else block
+libc-0.2.81/build.rs:124:5: this block may be rewritten with the `?` operator
+libc-0.2.81/build.rs:133:5: this block may be rewritten with the `?` operator
+libc-0.2.81/src/macros.rs:243:17: unsafe function's docs miss `# Safety` section
+libc-0.2.81/src/macros.rs:243:17: unsafe function's docs miss `# Safety` section
+libc-0.2.81/src/macros.rs:243:17: unsafe function's docs miss `# Safety` section
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:291:5: unsafe function's docs miss `# Safety` section
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:302:5: unsafe function's docs miss `# Safety` section
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:355:13: unsafe function's docs miss `# Safety` section
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:359:13: unsafe function's docs miss `# Safety` section
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:363:13: unsafe function's docs miss `# Safety` section
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:367:13: unsafe function's docs miss `# Safety` section
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:371:13: unsafe function's docs miss `# Safety` section
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2572:9: unneeded `return` statement
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2578:20: `0 as *mut _` detected
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2588:13: `0 as *mut _` detected
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2611:9: unneeded unit expression
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2619:9: unneeded unit expression
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2654:18: the operation is ineffective. Consider reducing it to `(dev & 0x00000000000000ff)`
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2665:16: the operation is ineffective. Consider reducing it to `(minor & 0x000000ff)`
+libc-0.2.81/src/unix/linux_like/mod.rs:1218:27: the operation is ineffective. Consider reducing it to `IPOPT_CONTROL`
+libc-0.2.81/src/unix/linux_like/mod.rs:1314:9: operator precedence can trip the unwary
+libc-0.2.81/src/unix/linux_like/mod.rs:1323:13: `0 as *mut _` detected
+libc-0.2.81/src/unix/linux_like/mod.rs:1344:9: unneeded `return` statement
+libc-0.2.81/src/unix/linux_like/mod.rs:1350:9: unneeded `return` statement
+libc-0.2.81/src/unix/linux_like/mod.rs:1357:9: unneeded `return` statement
+libc-0.2.81/src/unix/mod.rs:201:35: casting integer literal to `usize` is unnecessary
+libc-0.2.81/src/unix/mod.rs:202:35: casting integer literal to `usize` is unnecessary
+quote-1.0.7/src/ident_fragment.rs:51:31: stripping a prefix manually
+proc-macro2-1.0.24/src/fallback.rs:654:5: manual `RangeInclusive::contains` implementation
+proc-macro2-1.0.24/src/fallback.rs:655:12: manual `RangeInclusive::contains` implementation
+proc-macro2-1.0.24/src/fallback.rs:661:5: manual `RangeInclusive::contains` implementation
+proc-macro2-1.0.24/src/fallback.rs:662:12: manual `RangeInclusive::contains` implementation
+proc-macro2-1.0.24/src/fallback.rs:664:12: manual `RangeInclusive::contains` implementation
+proc-macro2-1.0.24/src/fallback.rs:674:37: manual `RangeInclusive::contains` implementation
+proc-macro2-1.0.24/src/parse.rs:552:5: this loop could be written as a `for` loop
+proc-macro2-1.0.24/src/parse.rs:584:21: manual `RangeInclusive::contains` implementation
+log-0.4.11/src/lib.rs:1093:5: you should consider adding a `Default` implementation for `MetadataBuilder<'a>`
+log-0.4.11/src/lib.rs:329:27: you are deriving `Hash` but have implemented `PartialEq` explicitly
+log-0.4.11/src/lib.rs:448:12: manual `RangeInclusive::contains` implementation
+log-0.4.11/src/lib.rs:520:27: you are deriving `Hash` but have implemented `PartialEq` explicitly
+log-0.4.11/src/lib.rs:908:5: you should consider adding a `Default` implementation for `RecordBuilder<'a>`
 regex-1.4.2/src/backtrack.rs:100:13: redundant field names in struct initialization
 regex-1.4.2/src/backtrack.rs:133:17: it looks like the same item is being pushed into this Vec
 regex-1.4.2/src/backtrack.rs:223:29: redundant field names in struct initialization
@@ -137,44 +386,3 @@ regex-1.4.2/src/utf8.rs:80:16: digits of hex or binary literal not grouped by fo
 regex-1.4.2/src/utf8.rs:92:23: digits of hex or binary literal not grouped by four
 regex-1.4.2/src/utf8.rs:92:9: digits of hex or binary literal not grouped by four
 regex-1.4.2/src/utf8.rs:97:16: digits of hex or binary literal not grouped by four
-cargo-0.49.0/src/bin/cargo/cli.rs:121:5: calling `push_str()` using a single-character string literal
-cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:353:56: stripping a prefix manually
-cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:762:5: this function's return value is unnecessarily wrapped by `Result`
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1664:5: field assignment outside of initializer for an instance created with Default::default()
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1795:5: field assignment outside of initializer for an instance created with Default::default()
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1980:24: stripping a prefix manually
-cargo-0.49.0/src/cargo/core/compiler/mod.rs:1131:1: this function's return value is unnecessarily wrapped by `Result`
-cargo-0.49.0/src/cargo/core/compiler/mod.rs:364:5: this function's return value is unnecessarily wrapped by `Result`
-cargo-0.49.0/src/cargo/core/compiler/mod.rs:693:1: this function's return value is unnecessarily wrapped by `Result`
-cargo-0.49.0/src/cargo/core/package.rs:421:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-cargo-0.49.0/src/cargo/core/profiles.rs:143:5: this function's return value is unnecessarily wrapped by `Result`
-cargo-0.49.0/src/cargo/core/profiles.rs:372:9: field assignment outside of initializer for an instance created with Default::default()
-cargo-0.49.0/src/cargo/core/resolver/errors.rs:305:17: calling `push_str()` using a single-character string literal
-cargo-0.49.0/src/cargo/core/resolver/resolve.rs:239:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-cargo-0.49.0/src/cargo/core/resolver/types.rs:187:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-cargo-0.49.0/src/cargo/core/resolver/types.rs:261:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-cargo-0.49.0/src/cargo/core/workspace.rs:1056:5: this function's return value is unnecessarily wrapped by `Result`
-cargo-0.49.0/src/cargo/core/workspace.rs:440:9: this function's return value is unnecessarily wrapped by `Result`
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:127:35: usage of `FromIterator::from_iter`
-cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:233:21: calling `push_str()` using a single-character string literal
-cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:370:5: this function's return value is unnecessarily wrapped by `Result`
-cargo-0.49.0/src/cargo/ops/fix.rs:608:9: field assignment outside of initializer for an instance created with Default::default()
-cargo-0.49.0/src/cargo/ops/fix.rs:619:48: stripping a prefix manually
-cargo-0.49.0/src/cargo/ops/lockfile.rs:154:13: calling `push_str()` using a single-character string literal
-cargo-0.49.0/src/cargo/ops/lockfile.rs:217:9: calling `push_str()` using a single-character string literal
-cargo-0.49.0/src/cargo/ops/lockfile.rs:87:1: this function's return value is unnecessarily wrapped by `Result`
-cargo-0.49.0/src/cargo/sources/git/source.rs:69:20: comparison to empty slice
-cargo-0.49.0/src/cargo/sources/git/utils.rs:1158:9: stripping a suffix manually
-cargo-0.49.0/src/cargo/sources/git/utils.rs:758:9: calling `push_str()` using a single-character string literal
-cargo-0.49.0/src/cargo/sources/path.rs:339:9: this function's return value is unnecessarily wrapped by `Result`
-cargo-0.49.0/src/cargo/sources/registry/index.rs:736:1: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-cargo-0.49.0/src/cargo/util/config/key.rs:69:9: calling `push_str()` using a single-character string literal
-cargo-0.49.0/src/cargo/util/config/value.rs:81:9: match expression looks like `matches!` macro
-cargo-0.49.0/src/cargo/util/errors.rs:473:5: manual `RangeInclusive::contains` implementation
-cargo-0.49.0/src/cargo/util/paths.rs:93:31: comparison to empty slice
-cargo-0.49.0/src/cargo/util/progress.rs:269:17: calling `push_str()` using a single-character string literal
-cargo-0.49.0/src/cargo/util/progress.rs:272:17: calling `push_str()` using a single-character string literal
-cargo-0.49.0/src/cargo/util/progress.rs:274:17: calling `push_str()` using a single-character string literal
-cargo-0.49.0/src/cargo/util/progress.rs:280:13: calling `push_str()` using a single-character string literal
-cargo-0.49.0/src/cargo/util/progress.rs:282:9: calling `push_str()` using a single-character string literal
-cargo-0.49.0/src/cargo/util/toml/mod.rs:1687:33: unnecessary closure used to substitute value for `Option::None`

From ccfaa338edead678687dcd690846470cbeee1dcd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= <matthias.krueger@famsik.de>
Date: Fri, 18 Dec 2020 22:08:18 +0100
Subject: [PATCH 085/108] cargo dev crater:  share target dir between clippy
 runs, enable pedantic and cargo lints, ignore tokei for now.

---
 clippy_dev/src/crater.rs |   14 +-
 mini-crater/logs.txt     | 2906 +++++++++++++++++++++++++++++++++++++-
 2 files changed, 2892 insertions(+), 28 deletions(-)

diff --git a/clippy_dev/src/crater.rs b/clippy_dev/src/crater.rs
index b23d9b4d9879c..eb301159a7b8a 100644
--- a/clippy_dev/src/crater.rs
+++ b/clippy_dev/src/crater.rs
@@ -1,6 +1,6 @@
+use crate::clippy_project_root;
 use std::path::PathBuf;
 use std::process::Command;
-
 // represents an archive we download from crates.io
 #[derive(Debug)]
 struct KrateSource {
@@ -75,7 +75,10 @@ impl Krate {
         println!("Linting {} {}...", &self.name, &self.version);
         let cargo_clippy_path = std::fs::canonicalize(cargo_clippy_path).unwrap();
 
+        let shared_target_dir = clippy_project_root().join("target/crater/shared_target_dir/");
+
         let all_output = std::process::Command::new(cargo_clippy_path)
+            .env("CARGO_TARGET_DIR", shared_target_dir)
             // lint warnings will look like this:
             // src/cargo/ops/cargo_compile.rs:127:35: warning: usage of `FromIterator::from_iter`
             .args(&[
@@ -83,10 +86,8 @@ impl Krate {
                 "--message-format=short",
                 "--",
                 "--cap-lints=warn",
-            /*    "--",
                 "-Wclippy::pedantic",
-                "--",
-                "-Wclippy::cargo", */
+                "-Wclippy::cargo",
             ])
             .current_dir(&self.path)
             .output()
@@ -135,7 +136,7 @@ pub fn run() {
         KrateSource::new("cargo", "0.49.0"),
         KrateSource::new("iron", "0.6.1"),
         KrateSource::new("ripgrep", "12.1.1"),
-        KrateSource::new("tokei", "12.0.4"),
+        //KrateSource::new("tokei", "12.0.4"),
         KrateSource::new("xsv", "0.13.0"),
         KrateSource::new("serde", "1.0.118"),
         KrateSource::new("rayon", "1.5.0"),
@@ -149,8 +150,7 @@ pub fn run() {
         KrateSource::new("proc-macro2", "1.0.24"),
         KrateSource::new("bitflags", "1.2.1"),
         KrateSource::new("log", "0.4.11"),
-        KrateSource::new("regex", "1.4.2")
-        //
+        KrateSource::new("regex", "1.4.2"),
     ];
 
     println!("Compiling clippy...");
diff --git a/mini-crater/logs.txt b/mini-crater/logs.txt
index b32d9f30d42dd..963b1fa38bf54 100644
--- a/mini-crater/logs.txt
+++ b/mini-crater/logs.txt
@@ -1,54 +1,1412 @@
+cargo-0.49.0/src/bin/cargo/cli.rs:104:34: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
 cargo-0.49.0/src/bin/cargo/cli.rs:121:5: calling `push_str()` using a single-character string literal
+cargo-0.49.0/src/bin/cargo/cli.rs:157:30: redundant closure found
+cargo-0.49.0/src/bin/cargo/cli.rs:184:41: casting `u64` to `u32` may truncate the value
+cargo-0.49.0/src/bin/cargo/cli.rs:196:42: redundant closure found
+cargo-0.49.0/src/bin/cargo/cli.rs:200:39: redundant closure found
+cargo-0.49.0/src/bin/cargo/cli.rs:231:1: more than 3 bools in a struct
+cargo-0.49.0/src/bin/cargo/cli.rs:245:22: casting `u64` to `u32` may truncate the value
+cargo-0.49.0/src/bin/cargo/cli.rs:247:47: redundant closure found
+cargo-0.49.0/src/bin/cargo/cli.rs:257:22: redundant closure found
+cargo-0.49.0/src/bin/cargo/cli.rs:26:20: redundant else block
+cargo-0.49.0/src/bin/cargo/cli.rs:7:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/commands/bench.rs:1:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/commands/bench.rs:76:59: redundant closure found
+cargo-0.49.0/src/bin/cargo/commands/build.rs:1:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/commands/check.rs:1:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/commands/clean.rs:1:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/commands/doc.rs:1:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/commands/fetch.rs:1:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/commands/fix.rs:1:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/commands/generate_lockfile.rs:1:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/commands/git_checkout.rs:1:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/commands/help.rs:20:1: item name ends with its containing module's name
+cargo-0.49.0/src/bin/cargo/commands/init.rs:1:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/commands/install.rs:1:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/commands/install.rs:97:16: use Option::map_or instead of an if let/else
+cargo-0.49.0/src/bin/cargo/commands/locate_project.rs:1:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/commands/login.rs:1:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/commands/metadata.rs:1:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/commands/mod.rs:1:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/commands/new.rs:1:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/commands/new.rs:20:24: use Option::map_or instead of an if let/else
+cargo-0.49.0/src/bin/cargo/commands/owner.rs:1:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/commands/owner.rs:38:43: redundant closure found
+cargo-0.49.0/src/bin/cargo/commands/owner.rs:39:43: redundant closure found
+cargo-0.49.0/src/bin/cargo/commands/owner.rs:40:43: redundant closure found
+cargo-0.49.0/src/bin/cargo/commands/owner.rs:43:30: redundant closure found
+cargo-0.49.0/src/bin/cargo/commands/owner.rs:46:30: redundant closure found
+cargo-0.49.0/src/bin/cargo/commands/package.rs:1:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/commands/pkgid.rs:1:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/commands/publish.rs:1:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/commands/publish.rs:40:47: redundant closure found
+cargo-0.49.0/src/bin/cargo/commands/read_manifest.rs:1:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/commands/run.rs:1:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/commands/rustc.rs:1:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/commands/rustdoc.rs:3:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/commands/search.rs:1:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/commands/test.rs:127:54: redundant closure found
+cargo-0.49.0/src/bin/cargo/commands/test.rs:1:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/commands/tree.rs:149:49: redundant closure found
+cargo-0.49.0/src/bin/cargo/commands/tree.rs:2:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/commands/uninstall.rs:1:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/commands/update.rs:1:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/commands/vendor.rs:1:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/commands/vendor.rs:96:16: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
+cargo-0.49.0/src/bin/cargo/commands/verify_project.rs:1:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/commands/version.rs:2:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/commands/yank.rs:1:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/commands/yank.rs:32:36: redundant closure found
+cargo-0.49.0/src/bin/cargo/commands/yank.rs:33:35: redundant closure found
+cargo-0.49.0/src/bin/cargo/commands/yank.rs:34:36: redundant closure found
+cargo-0.49.0/src/bin/cargo/commands/yank.rs:35:36: redundant closure found
+cargo-0.49.0/src/bin/cargo/main.rs:100:17: wildcard match will miss any future added variants
+cargo-0.49.0/src/bin/cargo/main.rs:118:41: redundant closure found
+cargo-0.49.0/src/bin/cargo/main.rs:137:43: redundant closure found
+cargo-0.49.0/src/bin/cargo/main.rs:148:19: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+cargo-0.49.0/src/bin/cargo/main.rs:174:57: redundant closure found
+cargo-0.49.0/src/bin/cargo/main.rs:18:5: usage of wildcard import
+cargo-0.49.0/src/bin/cargo/main.rs:72:22: redundant closure found
+cargo-0.49.0/src/bin/cargo/main.rs:94:13: wildcard match will miss any future added variants
+cargo-0.49.0/src/bin/cargo/main.rs:96:41: redundant closure found
+cargo-0.49.0/src/bin/cargo/main.rs:98:60: redundant closure found
+cargo-0.49.0/src/cargo/core/compiler/build_config.rs:155:13: usage of wildcard import for enum variants
+cargo-0.49.0/src/cargo/core/compiler/build_config.rs:170:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/compiler/build_config.rs:175:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/compiler/build_config.rs:180:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/compiler/build_config.rs:186:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/compiler/build_config.rs:197:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/compiler/build_config.rs:205:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/compiler/build_config.rs:51:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/compiler/build_config.rs:69:48: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+cargo-0.49.0/src/cargo/core/compiler/build_config.rs:96:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/compiler/build_context/mod.rs:44:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/compiler/build_context/mod.rs:83:20: you should put `x86_64` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:108:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:121:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:149:9: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:420:69: you should put `mode/target_kind` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:423:19: you should put `CrateTypes` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:424:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:469:58: redundant closure found
+cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:591:20: called `filter(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:603:19: redundant closure found
+cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:665:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:82:31: you should put `FileType` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:83:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:84:9: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:96:31: you should put `FileType` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:98:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/compiler/build_plan.rs:4:9: you should put `BuildPlan` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/compiler/build_plan.rs:5:66: you should put `BuildPlan` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/compiler/compilation.rs:150:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/compiler/compilation.rs:169:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/compiler/compilation.rs:185:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/compiler/compilation.rs:193:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/compiler/compilation.rs:194:49: redundant closure found
+cargo-0.49.0/src/cargo/core/compiler/compilation.rs:198:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/compiler/compilation.rs:314:16: you should put `rustc_tool` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/compiler/compilation.rs:91:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/compiler/compile_kind.rs:118:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/compiler/compile_kind.rs:147:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/compiler/compile_kind.rs:157:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/compiler/compile_kind.rs:29:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/compiler/compile_kind.rs:33:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/compiler/compile_kind.rs:49:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/compiler/context/compilation_files.rs:204:9: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+cargo-0.49.0/src/cargo/core/compiler/context/compilation_files.rs:277:22: you should put `OUT_DIR` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/compiler/context/compilation_files.rs:324:66: you should put `FileType` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/compiler/context/compilation_files.rs:393:37: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/core/compiler/context/compilation_files.rs:426:71: redundant closure found
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:125:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:125:5: this function has too many lines (107/100)
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:270:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:286:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:308:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:340:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:349:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:354:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:358:21: you should put `RunCustomBuild` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:361:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:365:9: called `find(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:374:43: you should put `RunCustomBuild` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:378:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:383:41: you should put `RunCustomBuild` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:384:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:391:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:397:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:523:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:538:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:542:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:83:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:92:25: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+cargo-0.49.0/src/cargo/core/compiler/crate_type.rs:16:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/compiler/crate_type.rs:29:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/compiler/crate_type.rs:40:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/compiler/crate_type.rs:49:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/compiler/crate_type.rs:60:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:150:1: this function has too many lines (230/100)
+cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:154:29: called `find(..).map(..)` on an `Iterator`
 cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:353:56: stripping a prefix manually
+cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:448:27: this argument is passed by value, but not consumed in the function body
+cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:464:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:481:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:48:56: you should put `RunCustomBuild` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:561:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:567:20: redundant closure found
+cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:576:28: `mut value` is being shadowed
+cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:606:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:624:13: called `find(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:688:5: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:756:5: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:762:5: adding items after statements is confusing, since items exist from the start of the scope
 cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:762:5: this function's return value is unnecessarily wrapped by `Result`
+cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:823:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1021:51: redundant closure found
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1252:20: called `filter(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1278:19: called `filter(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1656:16: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
 cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1664:5: field assignment outside of initializer for an instance created with Default::default()
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1787:5: binding's name is too similar to existing binding
 cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1795:5: field assignment outside of initializer for an instance created with Default::default()
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1882:17: binding's name is too similar to existing binding
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1894:17: binding's name is too similar to existing binding
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1906:9: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1917:9: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1923:9: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1956:9: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1962:9: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1963:22: casting `usize` to `u8` may truncate the value
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1964:22: casting `usize` to `u8` may truncate the value
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1965:22: casting `usize` to `u8` may truncate the value
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1966:22: casting `usize` to `u8` may truncate the value
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1980:17: binding's name is too similar to existing binding
 cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1980:24: stripping a prefix manually
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1986:17: binding's name is too similar to existing binding
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:2016:5: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:61:5: you should put `CompileMode` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:63:12: you should put `CompileKind` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:67:7: you should put `CARGO_DEFAULT_LIB_METADATA[^4` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:68:5: you should put `package_id` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:71:19: you should put `test/bench/for_host/edition` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:755:52: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:77:5: you should put `is_std` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:816:5: this function has too many lines (127/100)
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:863:64: binding's name is too similar to existing binding
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:875:33: binding's name is too similar to existing binding
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:876:32: binding's name is too similar to existing binding
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:896:30: binding's name is too similar to existing binding
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:897:30: binding's name is too similar to existing binding
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:991:37: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:12:5: you should put `src/librustc_jobserver/lib.rs` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:282:30: called `filter(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:329:13: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:332:23: this argument is passed by value, but not consumed in the function body
+cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:34:53: you should put `NeedsToken` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:35:6: you should put `ReleaseToken` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:37:6: you should put `NeedsToken` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:40:56: you should put `NeedsToken` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:40:5: you should put `NeedsToken` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:43:6: you should put `ReleaseToken` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:749:13: unnecessary boolean `not` operation
+cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:786:26: unused `self` argument
+cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:81:61: you should put `DrainState` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:865:13: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:871:13: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:890:9: unused `self` argument
+cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:93:24: you should put `JobQueue` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/compiler/links.rs:8:1: item name ends with its containing module's name
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:1016:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:1094:19: redundant closure found
 cargo-0.49.0/src/cargo/core/compiler/mod.rs:1131:1: this function's return value is unnecessarily wrapped by `Result`
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:1277:5: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:179:1: this function has too many lines (162/100)
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:198:78: redundant closure found
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:201:25: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:267:9: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:324:5: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:364:5: adding items after statements is confusing, since items exist from the start of the scope
 cargo-0.49.0/src/cargo/core/compiler/mod.rs:364:5: this function's return value is unnecessarily wrapped by `Result`
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:392:45: redundant closure found
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:415:23: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:667:15: binding's name is too similar to existing binding
 cargo-0.49.0/src/cargo/core/compiler/mod.rs:693:1: this function's return value is unnecessarily wrapped by `Result`
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:725:42: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:736:1: this function has too many lines (141/100)
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:73:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:777:12: unnecessary boolean `not` operation
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:873:5: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/core/compiler/output_depinfo.rs:41:13: wildcard match will miss any future added variants
+cargo-0.49.0/src/cargo/core/compiler/rustdoc.rs:16:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/core/compiler/rustdoc.rs:57:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/core/compiler/rustdoc.rs:72:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/compiler/standard_lib.rs:134:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/compiler/standard_lib.rs:16:1: this function could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/compiler/standard_lib.rs:30:28: redundant closure found
+cargo-0.49.0/src/cargo/core/compiler/standard_lib.rs:34:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/compiler/timings.rs:16:1: more than 3 bools in a struct
+cargo-0.49.0/src/cargo/core/compiler/timings.rs:192:64: this argument is passed by value, but not consumed in the function body
+cargo-0.49.0/src/cargo/core/compiler/timings.rs:212:58: this argument is passed by value, but not consumed in the function body
+cargo-0.49.0/src/cargo/core/compiler/timings.rs:234:13: non-binding `let` on a type that implements `Drop`
+cargo-0.49.0/src/cargo/core/compiler/timings.rs:355:13: casting `f64` to `u32` may lose the sign of the value
+cargo-0.49.0/src/cargo/core/compiler/timings.rs:355:13: casting `f64` to `u32` may truncate the value
+cargo-0.49.0/src/cargo/core/compiler/timings.rs:397:38: casting `f64` to `u32` may lose the sign of the value
+cargo-0.49.0/src/cargo/core/compiler/timings.rs:397:38: casting `f64` to `u32` may truncate the value
+cargo-0.49.0/src/cargo/core/compiler/timings.rs:484:9: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/core/compiler/timings.rs:605:38: you should put `rmeta_time` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/compiler/timings.rs:605:50: you should put `codegen_time` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/compiler/timings.rs:641:26: literal non-ASCII character detected
+cargo-0.49.0/src/cargo/core/compiler/unit.rs:100:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/compiler/unit.rs:151:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/core/compiler/unit.rs:161:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/compiler/unit.rs:35:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/core/compiler/unit_dependencies.rs:154:29: you should put `state.unit_dependencies` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/compiler/unit_dependencies.rs:213:1: this function has too many lines (110/100)
+cargo-0.49.0/src/cargo/core/compiler/unit_dependencies.rs:329:13: called `filter(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/core/compiler/unit_dependencies.rs:480:5: called `find(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/core/compiler/unit_dependencies.rs:511:5: called `find(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/core/compiler/unit_dependencies.rs:52:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/compiler/unit_dependencies.rs:52:1: item name ends with its containing module's name
+cargo-0.49.0/src/cargo/core/compiler/unit_graph.rs:65:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/compiler/unit_graph.rs:65:1: item name ends with its containing module's name
+cargo-0.49.0/src/cargo/core/dependency.rs:157:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/dependency.rs:182:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/dependency.rs:203:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/dependency.rs:224:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/dependency.rs:23:1: more than 3 bools in a struct
+cargo-0.49.0/src/cargo/core/dependency.rs:248:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/dependency.rs:270:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/dependency.rs:274:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/dependency.rs:278:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/dependency.rs:287:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/dependency.rs:291:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/dependency.rs:305:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/dependency.rs:311:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/dependency.rs:319:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/dependency.rs:337:75: redundant closure found
+cargo-0.49.0/src/cargo/core/dependency.rs:397:56: redundant closure found
+cargo-0.49.0/src/cargo/core/dependency.rs:403:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/dependency.rs:408:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/dependency.rs:415:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/dependency.rs:419:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/dependency.rs:424:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/dependency.rs:428:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/dependency.rs:433:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/dependency.rs:438:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/dependency.rs:443:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/dependency.rs:449:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/dependency.rs:450:9: unnecessary `!=` operation
+cargo-0.49.0/src/cargo/core/features.rs:119:17: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/features.rs:229:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/features.rs:274:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/features.rs:278:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/features.rs:306:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/features.rs:338:1: more than 3 bools in a struct
+cargo-0.49.0/src/cargo/core/features.rs:362:25: consider using `Option<T>` instead of `Option<Option<T>>` or a custom enum if you need to distinguish all 3 cases
+cargo-0.49.0/src/cargo/core/features.rs:380:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/features.rs:401:9: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/core/features.rs:409:9: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/core/features.rs:412:45: redundant closure found
+cargo-0.49.0/src/cargo/core/features.rs:416:9: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/core/features.rs:419:45: redundant closure found
+cargo-0.49.0/src/cargo/core/features.rs:424:9: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/core/features.rs:431:9: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/core/features.rs:477:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/features.rs:509:1: this function could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/features.rs:518:5: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
+cargo-0.49.0/src/cargo/core/features.rs:542:1: this function could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/features.rs:543:37: redundant closure found
+cargo-0.49.0/src/cargo/core/features.rs:547:60: redundant closure found
+cargo-0.49.0/src/cargo/core/features.rs:556:1: item name ends with its containing module's name
+cargo-0.49.0/src/cargo/core/features.rs:563:1: item name ends with its containing module's name
+cargo-0.49.0/src/cargo/core/manifest.rs:116:13: usage of wildcard import for enum variants
+cargo-0.49.0/src/cargo/core/manifest.rs:118:58: redundant closure found
+cargo-0.49.0/src/cargo/core/manifest.rs:130:13: usage of wildcard import for enum variants
+cargo-0.49.0/src/cargo/core/manifest.rs:143:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:159:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:162:34: redundant closure found
+cargo-0.49.0/src/cargo/core/manifest.rs:169:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:17:5: usage of wildcard import
+cargo-0.49.0/src/cargo/core/manifest.rs:189:1: more than 3 bools in a struct
+cargo-0.49.0/src/cargo/core/manifest.rs:215:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:222:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:22:1: item name ends with its containing module's name
+cargo-0.49.0/src/cargo/core/manifest.rs:360:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:407:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:410:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:413:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:416:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:419:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:422:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:425:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:431:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:438:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:444:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:447:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:450:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:453:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:456:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:459:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:462:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:466:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:470:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:477:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:481:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:488:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/manifest.rs:512:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:516:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:520:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:524:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:528:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:538:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:557:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:561:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:565:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:569:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:577:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:581:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:588:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:617:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:632:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:648:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:659:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:66:1: item name ends with its containing module's name
+cargo-0.49.0/src/cargo/core/manifest.rs:670:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:693:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:708:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:723:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:726:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:729:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:735:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:738:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:741:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:744:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:747:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:751:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:754:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:757:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:760:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:763:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:767:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:776:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:780:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:787:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:798:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:800:56: redundant closure found
+cargo-0.49.0/src/cargo/core/manifest.rs:805:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:809:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:818:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:823:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:828:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:831:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:834:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:839:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:85:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/core/manifest.rs:888:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/manifest.rs:936:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/package.rs:1075:28: redundant closure found
+cargo-0.49.0/src/cargo/core/package.rs:160:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/package.rs:170:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/package.rs:174:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/package.rs:182:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/package.rs:186:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/package.rs:190:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/package.rs:194:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/package.rs:198:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/package.rs:202:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/package.rs:206:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/package.rs:210:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/package.rs:217:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/package.rs:221:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/package.rs:222:35: redundant closure found
+cargo-0.49.0/src/cargo/core/package.rs:226:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/package.rs:227:35: redundant closure found
+cargo-0.49.0/src/cargo/core/package.rs:230:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/package.rs:239:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/package.rs:249:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/package.rs:287:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/core/package.rs:385:5: docs for function returning `Result` missing `# Errors` section
 cargo-0.49.0/src/cargo/core/package.rs:421:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+cargo-0.49.0/src/cargo/core/package.rs:425:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/package.rs:452:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/package.rs:453:60: redundant closure found
+cargo-0.49.0/src/cargo/core/package.rs:459:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/package.rs:473:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/package.rs:587:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/package.rs:682:46: casting `f64` to `u64` may lose the sign of the value
+cargo-0.49.0/src/cargo/core/package.rs:682:46: casting `f64` to `u64` may truncate the value
+cargo-0.49.0/src/cargo/core/package.rs:682:63: casting `f64` to `u64` may lose the sign of the value
+cargo-0.49.0/src/cargo/core/package.rs:682:63: casting `f64` to `u64` may truncate the value
+cargo-0.49.0/src/cargo/core/package.rs:731:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/package.rs:790:13: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+cargo-0.49.0/src/cargo/core/package.rs:988:9: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+cargo-0.49.0/src/cargo/core/package_id.rs:115:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/package_id.rs:124:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/package_id.rs:139:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/package_id.rs:142:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/package_id.rs:145:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/package_id.rs:149:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/package_id.rs:157:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/package_id.rs:161:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/package_id.rs:169:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/package_id.rs:174:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/core/package_id_spec.rs:101:39: redundant closure found
+cargo-0.49.0/src/cargo/core/package_id_spec.rs:143:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/package_id_spec.rs:147:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/package_id_spec.rs:151:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/package_id_spec.rs:160:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/package_id_spec.rs:179:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/package_id_spec.rs:212:9: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/core/package_id_spec.rs:231:9: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+cargo-0.49.0/src/cargo/core/package_id_spec.rs:51:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/package_id_spec.rs:77:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/package_id_spec.rs:88:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/profiles.rs:1004:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/profiles.rs:1014:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/profiles.rs:1018:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/profiles.rs:1028:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/profiles.rs:106:9: adding items after statements is confusing, since items exist from the start of the scope
 cargo-0.49.0/src/cargo/core/profiles.rs:143:5: this function's return value is unnecessarily wrapped by `Result`
+cargo-0.49.0/src/cargo/core/profiles.rs:286:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/profiles.rs:294:40: unnecessary boolean `not` operation
+cargo-0.49.0/src/cargo/core/profiles.rs:30:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/profiles.rs:342:25: `maker` is being shadowed
+cargo-0.49.0/src/cargo/core/profiles.rs:370:41: unused `self` argument
+cargo-0.49.0/src/cargo/core/profiles.rs:370:5: this method could have a `#[must_use]` attribute
 cargo-0.49.0/src/cargo/core/profiles.rs:372:9: field assignment outside of initializer for an instance created with Default::default()
+cargo-0.49.0/src/cargo/core/profiles.rs:382:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/profiles.rs:383:28: unnecessary boolean `not` operation
+cargo-0.49.0/src/cargo/core/profiles.rs:397:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/profiles.rs:405:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/profiles.rs:607:1: more than 3 bools in a struct
+cargo-0.49.0/src/cargo/core/profiles.rs:909:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/profiles.rs:923:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/profiles.rs:934:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/profiles.rs:987:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/registry.rs:111:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/registry.rs:127:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/registry.rs:168:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/registry.rs:19:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/registry.rs:240:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/registry.rs:26:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/registry.rs:344:49: redundant closure found
+cargo-0.49.0/src/cargo/core/registry.rs:369:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/registry.rs:424:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/registry.rs:49:1: item name ends with its containing module's name
+cargo-0.49.0/src/cargo/core/registry.rs:520:17: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+cargo-0.49.0/src/cargo/core/registry.rs:763:53: redundant closure found
+cargo-0.49.0/src/cargo/core/registry.rs:765:53: redundant closure found
+cargo-0.49.0/src/cargo/core/registry.rs:807:14: redundant closure found
+cargo-0.49.0/src/cargo/core/registry.rs:814:53: redundant closure found
+cargo-0.49.0/src/cargo/core/resolver/conflict_cache.rs:197:29: redundant closure found
+cargo-0.49.0/src/cargo/core/resolver/conflict_cache.rs:41:38: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
+cargo-0.49.0/src/cargo/core/resolver/context.rs:274:53: redundant closure found
+cargo-0.49.0/src/cargo/core/resolver/context.rs:297:9: called `filter(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/core/resolver/context.rs:42:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/core/resolver/context.rs:74:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/resolver/encode.rs:156:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/resolver/encode.rs:156:5: this function has too many lines (164/100)
+cargo-0.49.0/src/cargo/core/resolver/encode.rs:339:17: wildcard match will miss any future added variants
+cargo-0.49.0/src/cargo/core/resolver/encode.rs:438:5: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/core/resolver/encode.rs:449:5: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/core/resolver/encode.rs:529:34: redundant closure found
+cargo-0.49.0/src/cargo/core/resolver/encode.rs:602:59: redundant closure found
+cargo-0.49.0/src/cargo/core/resolver/encode.rs:623:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/core/resolver/encode.rs:652:27: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+cargo-0.49.0/src/cargo/core/resolver/encode.rs:674:51: redundant closure found
+cargo-0.49.0/src/cargo/core/resolver/errors.rs:103:22: redundant closure found
+cargo-0.49.0/src/cargo/core/resolver/errors.rs:104:22: redundant closure found
+cargo-0.49.0/src/cargo/core/resolver/errors.rs:206:9: unnecessary boolean `not` operation
+cargo-0.49.0/src/cargo/core/resolver/errors.rs:257:45: redundant closure found
+cargo-0.49.0/src/cargo/core/resolver/errors.rs:27:5: this method could have a `#[must_use]` attribute
 cargo-0.49.0/src/cargo/core/resolver/errors.rs:305:17: calling `push_str()` using a single-character string literal
+cargo-0.49.0/src/cargo/core/resolver/errors.rs:70:1: this function has too many lines (207/100)
+cargo-0.49.0/src/cargo/core/resolver/features.rs:104:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/core/resolver/features.rs:111:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/resolver/features.rs:162:56: redundant closure found
+cargo-0.49.0/src/cargo/core/resolver/features.rs:179:1: item name ends with its containing module's name
+cargo-0.49.0/src/cargo/core/resolver/features.rs:186:23: you should put `RequestedFeatures` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/resolver/features.rs:187:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/resolver/features.rs:199:23: you should put `RequestedFeatures` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/resolver/features.rs:200:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/resolver/features.rs:209:9: called `filter(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/core/resolver/features.rs:221:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/resolver/features.rs:231:21: you should put `pkg_id/is_build` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/resolver/features.rs:233:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/resolver/features.rs:247:58: redundant closure found
+cargo-0.49.0/src/cargo/core/resolver/features.rs:278:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/resolver/features.rs:394:27: you should put `FeatureValue` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/resolver/features.rs:460:19: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+cargo-0.49.0/src/cargo/core/resolver/features.rs:480:24: you should put `FeatureValues` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/resolver/features.rs:496:24: you should put `FeatureValues` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/resolver/features.rs:561:28: called `filter(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/core/resolver/features.rs:58:1: item name ends with its containing module's name
+cargo-0.49.0/src/cargo/core/resolver/features.rs:67:1: more than 3 bools in a struct
+cargo-0.49.0/src/cargo/core/resolver/mod.rs:1017:5: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/core/resolver/mod.rs:1045:57: redundant closure found
+cargo-0.49.0/src/cargo/core/resolver/mod.rs:122:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/resolver/mod.rs:142:44: redundant closure found
+cargo-0.49.0/src/cargo/core/resolver/mod.rs:180:1: this function has too many lines (225/100)
+cargo-0.49.0/src/cargo/core/resolver/mod.rs:311:17: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+cargo-0.49.0/src/cargo/core/resolver/mod.rs:421:52: called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find_map(..)` instead.
+cargo-0.49.0/src/cargo/core/resolver/mod.rs:437:33: called `filter(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/core/resolver/mod.rs:457:69: called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find_map(..)` instead.
+cargo-0.49.0/src/cargo/core/resolver/mod.rs:470:37: binding's name is too similar to existing binding
+cargo-0.49.0/src/cargo/core/resolver/mod.rs:480:37: called `filter(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/core/resolver/mod.rs:607:11: this argument is passed by value, but not consumed in the function body
+cargo-0.49.0/src/cargo/core/resolver/mod.rs:631:21: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+cargo-0.49.0/src/cargo/core/resolver/mod.rs:942:15: unnecessary boolean `not` operation
+cargo-0.49.0/src/cargo/core/resolver/mod.rs:988:20: redundant else block
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:120:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:132:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:199:24: redundant else block
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:235:5: this method could have a `#[must_use]` attribute
 cargo-0.49.0/src/cargo/core/resolver/resolve.rs:239:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:255:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:259:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:263:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:269:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:273:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:274:9: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:280:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:284:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:288:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:292:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:296:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:300:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:315:13: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:354:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:362:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:60:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:76:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:90:35: called `filter(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/core/resolver/types.rs:111:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/resolver/types.rs:121:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/resolver/types.rs:141:19: you should put `ResolveOpts` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/resolver/types.rs:142:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/resolver/types.rs:149:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/resolver/types.rs:181:9: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
 cargo-0.49.0/src/cargo/core/resolver/types.rs:187:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
 cargo-0.49.0/src/cargo/core/resolver/types.rs:261:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+cargo-0.49.0/src/cargo/core/shell.rs:113:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/shell.rs:130:9: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+cargo-0.49.0/src/cargo/core/shell.rs:148:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/shell.rs:153:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/shell.rs:163:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/shell.rs:18:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/shell.rs:198:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/shell.rs:206:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/shell.rs:214:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/shell.rs:228:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/shell.rs:239:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/shell.rs:250:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/shell.rs:259:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/shell.rs:267:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/shell.rs:26:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/shell.rs:277:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/shell.rs:282:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/shell.rs:314:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/shell.rs:322:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/shell.rs:330:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/shell.rs:98:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/source/mod.rs:103:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/source/mod.rs:247:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/core/source/mod.rs:261:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/source/mod.rs:268:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/source/mod.rs:273:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/source/mod.rs:291:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/source/mod.rs:302:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/source/mod.rs:307:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/source/mod.rs:31:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/source/mod.rs:37:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/source/mod.rs:39:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/source/mod.rs:47:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/source/mod.rs:50:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/source/mod.rs:52:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/source/mod.rs:63:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/source/mod.rs:74:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/source/mod.rs:83:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/source/source_id.rs:107:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/source/source_id.rs:128:50: redundant closure found
+cargo-0.49.0/src/cargo/core/source/source_id.rs:147:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/source/source_id.rs:156:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/source/source_id.rs:162:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/source/source_id.rs:166:19: you should put `SourceId` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/source/source_id.rs:167:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/source/source_id.rs:171:19: you should put `SourceId` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/source/source_id.rs:172:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/source/source_id.rs:178:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/source/source_id.rs:187:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/source/source_id.rs:18:74: calling `std::sync::Mutex::default()` is more clear than this expression
+cargo-0.49.0/src/cargo/core/source/source_id.rs:195:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/source/source_id.rs:207:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/source/source_id.rs:213:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/source/source_id.rs:217:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/source/source_id.rs:225:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/source/source_id.rs:228:16: use Option::map_or_else instead of an if let/else
+cargo-0.49.0/src/cargo/core/source/source_id.rs:236:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/source/source_id.rs:241:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/source/source_id.rs:252:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/source/source_id.rs:257:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/source/source_id.rs:262:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/source/source_id.rs:305:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/source/source_id.rs:310:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/source/source_id.rs:318:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/source/source_id.rs:326:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/source/source_id.rs:355:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/source/source_id.rs:393:61: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/core/source/source_id.rs:394:42: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/core/source/source_id.rs:395:42: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/core/source/source_id.rs:397:71: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/core/source/source_id.rs:397:71: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/core/source/source_id.rs:398:47: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/core/source/source_id.rs:398:47: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/core/source/source_id.rs:399:47: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/core/source/source_id.rs:399:47: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/core/source/source_id.rs:401:63: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/core/source/source_id.rs:401:63: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/core/source/source_id.rs:401:63: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/core/source/source_id.rs:402:43: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/core/source/source_id.rs:402:43: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/core/source/source_id.rs:402:43: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/core/source/source_id.rs:403:43: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/core/source/source_id.rs:403:43: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/core/source/source_id.rs:403:43: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/core/source/source_id.rs:406:21: usage of wildcard import for enum variants
+cargo-0.49.0/src/cargo/core/source/source_id.rs:412:41: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/core/source/source_id.rs:413:36: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/core/source/source_id.rs:414:36: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/core/source/source_id.rs:420:47: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/core/source/source_id.rs:420:47: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/core/source/source_id.rs:494:42: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/core/source/source_id.rs:512:17: integer type suffix should be separated by an underscore
+cargo-0.49.0/src/cargo/core/source/source_id.rs:513:17: integer type suffix should be separated by an underscore
+cargo-0.49.0/src/cargo/core/source/source_id.rs:517:17: integer type suffix should be separated by an underscore
+cargo-0.49.0/src/cargo/core/source/source_id.rs:518:17: integer type suffix should be separated by an underscore
+cargo-0.49.0/src/cargo/core/source/source_id.rs:525:17: integer type suffix should be separated by an underscore
+cargo-0.49.0/src/cargo/core/source/source_id.rs:526:17: integer type suffix should be separated by an underscore
+cargo-0.49.0/src/cargo/core/source/source_id.rs:530:17: integer type suffix should be separated by an underscore
+cargo-0.49.0/src/cargo/core/source/source_id.rs:531:17: integer type suffix should be separated by an underscore
+cargo-0.49.0/src/cargo/core/source/source_id.rs:535:33: integer type suffix should be separated by an underscore
+cargo-0.49.0/src/cargo/core/source/source_id.rs:536:37: integer type suffix should be separated by an underscore
+cargo-0.49.0/src/cargo/core/source/source_id.rs:537:42: integer type suffix should be separated by an underscore
+cargo-0.49.0/src/cargo/core/source/source_id.rs:538:38: integer type suffix should be separated by an underscore
+cargo-0.49.0/src/cargo/core/source/source_id.rs:548:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/core/source/source_id.rs:597:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/summary.rs:103:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/summary.rs:123:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/summary.rs:150:1: this function has too many lines (141/100)
+cargo-0.49.0/src/cargo/core/summary.rs:158:9: usage of wildcard import for enum variants
+cargo-0.49.0/src/cargo/core/summary.rs:181:21: unnecessary boolean `not` operation
+cargo-0.49.0/src/cargo/core/summary.rs:192:28: redundant else block
+cargo-0.49.0/src/cargo/core/summary.rs:258:32: redundant else block
+cargo-0.49.0/src/cargo/core/summary.rs:281:28: redundant else block
+cargo-0.49.0/src/cargo/core/summary.rs:303:28: redundant else block
+cargo-0.49.0/src/cargo/core/summary.rs:321:51: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/core/summary.rs:344:5: you should put `FeatureValue` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/summary.rs:350:85: you should put `FeatureValue` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/summary.rs:36:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/summary.rs:378:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/summary.rs:386:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/summary.rs:387:13: usage of wildcard import for enum variants
+cargo-0.49.0/src/cargo/core/summary.rs:407:13: usage of wildcard import for enum variants
+cargo-0.49.0/src/cargo/core/summary.rs:69:34: redundant closure found
+cargo-0.49.0/src/cargo/core/summary.rs:75:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/summary.rs:78:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/summary.rs:81:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/summary.rs:84:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/summary.rs:87:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/summary.rs:90:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/summary.rs:93:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/summary.rs:96:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/summary.rs:99:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/workspace.rs:1019:59: called `filter(..).map(..)` on an `Iterator`
 cargo-0.49.0/src/cargo/core/workspace.rs:1056:5: this function's return value is unnecessarily wrapped by `Result`
+cargo-0.49.0/src/cargo/core/workspace.rs:113:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/core/workspace.rs:1157:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/core/workspace.rs:128:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/core/workspace.rs:150:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/workspace.rs:159:16: redundant else block
+cargo-0.49.0/src/cargo/core/workspace.rs:197:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/workspace.rs:225:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/workspace.rs:255:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/workspace.rs:267:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/workspace.rs:329:37: you should put `VirtualManifest` between ticks in the documentation
+cargo-0.49.0/src/cargo/core/workspace.rs:410:5: docs for function returning `Result` missing `# Errors` section
 cargo-0.49.0/src/cargo/core/workspace.rs:440:9: this function's return value is unnecessarily wrapped by `Result`
+cargo-0.49.0/src/cargo/core/workspace.rs:511:32: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+cargo-0.49.0/src/cargo/core/workspace.rs:561:25: literal non-ASCII character detected
+cargo-0.49.0/src/cargo/core/workspace.rs:613:13: called `filter_map(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/core/workspace.rs:615:22: redundant closure found
+cargo-0.49.0/src/cargo/core/workspace.rs:688:35: called `filter(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/core/workspace.rs:762:27: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+cargo-0.49.0/src/cargo/core/workspace.rs:784:17: unnecessary boolean `not` operation
+cargo-0.49.0/src/cargo/core/workspace.rs:849:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/workspace.rs:893:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/core/workspace.rs:906:24: redundant else block
+cargo-0.49.0/src/cargo/core/workspace.rs:932:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/lib.rs:177:1: this function could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/lib.rs:180:36: redundant closure found
+cargo-0.49.0/src/cargo/lib.rs:180:36: redundant closure found
+cargo-0.49.0/src/cargo/lib.rs:180:36: redundant closure found
+cargo-0.49.0/src/cargo/lib.rs:180:36: redundant closure found
+cargo-0.49.0/src/cargo/lib.rs:180:36: redundant closure found
+cargo-0.49.0/src/cargo/ops/cargo_clean.rs:205:23: redundant closure found
+cargo-0.49.0/src/cargo/ops/cargo_clean.rs:27:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/cargo_clean.rs:27:1: this function has too many lines (120/100)
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:1078:14: redundant closure found
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:109:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:119:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:1227:17: this argument is passed by value, but not consumed in the function body
 cargo-0.49.0/src/cargo/ops/cargo_compile.rs:127:35: usage of `FromIterator::from_iter`
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:128:32: called `filter(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:173:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:205:36: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:242:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:249:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:258:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:275:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:275:1: this function has too many lines (219/100)
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:468:9: calling `std::collections::HashMap::default()` is more clear than this expression
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:548:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:556:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:574:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:583:21: you should put `CompileFilter` between ticks in the documentation
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:584:5: more than 3 bools in function parameters
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:584:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:592:9: binding's name is too similar to existing binding
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:593:9: binding's name is too similar to existing binding
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:607:13: binding's name is too similar to existing binding
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:612:21: you should put `CompileFilter` between ticks in the documentation
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:613:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:618:9: binding's name is too similar to existing binding
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:641:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:652:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:655:50: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:673:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:692:49: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:703:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:729:1: this function has too many lines (205/100)
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:82:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:874:69: redundant closure found
+cargo-0.49.0/src/cargo/ops/cargo_doc.rs:20:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/cargo_fetch.rs:15:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/cargo_fetch.rs:27:46: redundant closure found
+cargo-0.49.0/src/cargo/ops/cargo_fetch.rs:36:20: called `filter(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/ops/cargo_generate_lockfile.rs:160:5: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/ops/cargo_generate_lockfile.rs:175:5: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/ops/cargo_generate_lockfile.rs:22:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/cargo_generate_lockfile.rs:37:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/cargo_generate_lockfile.rs:37:1: this function has too many lines (171/100)
+cargo-0.49.0/src/cargo/ops/cargo_install.rs:13:5: usage of wildcard import
+cargo-0.49.0/src/cargo/ops/cargo_install.rs:148:1: more than 3 bools in function parameters
+cargo-0.49.0/src/cargo/ops/cargo_install.rs:148:1: this function has too many lines (316/100)
+cargo-0.49.0/src/cargo/ops/cargo_install.rs:202:17: redundant closure found
+cargo-0.49.0/src/cargo/ops/cargo_install.rs:312:64: redundant closure found
+cargo-0.49.0/src/cargo/ops/cargo_install.rs:318:63: called `filter(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/ops/cargo_install.rs:32:13: non-binding `let` on a type that implements `Drop`
+cargo-0.49.0/src/cargo/ops/cargo_install.rs:37:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/cargo_install.rs:454:22: redundant closure found
+cargo-0.49.0/src/cargo/ops/cargo_install.rs:483:5: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/ops/cargo_install.rs:683:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/cargo_new.rs:101:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/cargo_new.rs:245:5: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/ops/cargo_new.rs:251:5: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/ops/cargo_new.rs:367:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/cargo_new.rs:405:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/cargo_new.rs:489:5: you should put `IgnoreList` between ticks in the documentation
+cargo-0.49.0/src/cargo/ops/cargo_new.rs:525:47: you should put `IgnoreList` between ticks in the documentation
+cargo-0.49.0/src/cargo/ops/cargo_new.rs:525:9: you should put `format_existing` between ticks in the documentation
+cargo-0.49.0/src/cargo/ops/cargo_new.rs:572:34: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/ops/cargo_new.rs:623:1: this function has too many lines (130/100)
+cargo-0.49.0/src/cargo/ops/cargo_new.rs:781:5: called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find_map(..)` instead.
+cargo-0.49.0/src/cargo/ops/cargo_new.rs:800:16: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+cargo-0.49.0/src/cargo/ops/cargo_output_metadata.rs:163:36: redundant closure found
+cargo-0.49.0/src/cargo/ops/cargo_output_metadata.rs:27:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/cargo_output_metadata.rs:45:45: redundant closure found
+cargo-0.49.0/src/cargo/ops/cargo_package.rs:144:1: this function has too many lines (112/100)
+cargo-0.49.0/src/cargo/ops/cargo_package.rs:207:13: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+cargo-0.49.0/src/cargo/ops/cargo_package.rs:25:1: more than 3 bools in a struct
+cargo-0.49.0/src/cargo/ops/cargo_package.rs:307:54: redundant closure found
+cargo-0.49.0/src/cargo/ops/cargo_package.rs:394:5: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/ops/cargo_package.rs:418:21: called `filter(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/ops/cargo_package.rs:425:61: redundant closure found
+cargo-0.49.0/src/cargo/ops/cargo_package.rs:459:5: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/ops/cargo_package.rs:66:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/cargo_package.rs:769:29: called `filter(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/ops/cargo_package.rs:93:20: unnecessary boolean `not` operation
+cargo-0.49.0/src/cargo/ops/cargo_pkgid.rs:5:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/cargo_read_manifest.rs:14:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/cargo_read_manifest.rs:171:5: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/ops/cargo_read_manifest.rs:37:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/cargo_read_manifest.rs:57:49: redundant closure found
+cargo-0.49.0/src/cargo/ops/cargo_read_manifest.rs:69:37: redundant closure found
+cargo-0.49.0/src/cargo/ops/cargo_run.rs:25:24: unnecessary boolean `not` operation
+cargo-0.49.0/src/cargo/ops/cargo_run.rs:35:9: unnecessary boolean `not` operation
+cargo-0.49.0/src/cargo/ops/cargo_run.rs:37:16: redundant else block
+cargo-0.49.0/src/cargo/ops/cargo_run.rs:53:9: unnecessary boolean `not` operation
+cargo-0.49.0/src/cargo/ops/cargo_run.rs:65:16: redundant else block
+cargo-0.49.0/src/cargo/ops/cargo_run.rs:9:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/cargo_test.rs:16:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/cargo_test.rs:43:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/cargo_test.rs:84:17: binding's name is too similar to existing binding
+cargo-0.49.0/src/cargo/ops/cargo_uninstall.rs:14:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/cargo_uninstall.rs:7:5: usage of wildcard import
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:147:9: you should put `PackageId` between ticks in the documentation
 cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:233:21: calling `push_str()` using a single-character string literal
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:244:22: you should put `PackageId` between ticks in the documentation
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:244:63: you should put `PackageId` between ticks in the documentation
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:253:17: unnecessary boolean `not` operation
 cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:370:5: this function's return value is unnecessarily wrapped by `Result`
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:392:9: called `find(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:505:8: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:525:10: this argument is passed by value, but not consumed in the function body
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:542:27: redundant closure found
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:542:5: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:561:20: redundant else block
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:613:5: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:645:41: you should put `BTreeSet` between ticks in the documentation
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:654:42: called `filter(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:662:14: called `filter(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:674:17: called `filter(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:681:17: called `filter(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:92:19: you should put `InstallTracker` between ticks in the documentation
+cargo-0.49.0/src/cargo/ops/fix.rs:200:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/fix.rs:200:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/ops/fix.rs:424:20: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
+cargo-0.49.0/src/cargo/ops/fix.rs:455:13: binding's name is too similar to existing binding
+cargo-0.49.0/src/cargo/ops/fix.rs:506:17: binding's name is too similar to existing binding
 cargo-0.49.0/src/cargo/ops/fix.rs:608:9: field assignment outside of initializer for an instance created with Default::default()
+cargo-0.49.0/src/cargo/ops/fix.rs:612:42: redundant closure found
 cargo-0.49.0/src/cargo/ops/fix.rs:619:48: stripping a prefix manually
+cargo-0.49.0/src/cargo/ops/fix.rs:66:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/ops/fix.rs:66:1: more than 3 bools in a struct
+cargo-0.49.0/src/cargo/ops/fix.rs:708:18: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/ops/fix.rs:77:1: docs for function returning `Result` missing `# Errors` section
 cargo-0.49.0/src/cargo/ops/lockfile.rs:154:13: calling `push_str()` using a single-character string literal
 cargo-0.49.0/src/cargo/ops/lockfile.rs:217:9: calling `push_str()` using a single-character string literal
+cargo-0.49.0/src/cargo/ops/lockfile.rs:30:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/lockfile.rs:35:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/lockfile.rs:35:1: item name ends with its containing module's name
 cargo-0.49.0/src/cargo/ops/lockfile.rs:87:1: this function's return value is unnecessarily wrapped by `Result`
+cargo-0.49.0/src/cargo/ops/lockfile.rs:8:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/lockfile.rs:8:1: item name ends with its containing module's name
+cargo-0.49.0/src/cargo/ops/registry.rs:150:21: redundant closure found
+cargo-0.49.0/src/cargo/ops/registry.rs:188:1: this function has too many lines (130/100)
+cargo-0.49.0/src/cargo/ops/registry.rs:196:16: called `filter(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/ops/registry.rs:212:32: unnecessary `!=` operation
+cargo-0.49.0/src/cargo/ops/registry.rs:222:53: redundant closure found
+cargo-0.49.0/src/cargo/ops/registry.rs:224:44: redundant closure found
+cargo-0.49.0/src/cargo/ops/registry.rs:31:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/ops/registry.rs:346:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/registry.rs:346:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/ops/registry.rs:351:26: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+cargo-0.49.0/src/cargo/ops/registry.rs:385:12: this argument is passed by value, but not consumed in the function body
+cargo-0.49.0/src/cargo/ops/registry.rs:386:15: this argument is passed by value, but not consumed in the function body
+cargo-0.49.0/src/cargo/ops/registry.rs:38:1: more than 3 bools in a struct
+cargo-0.49.0/src/cargo/ops/registry.rs:477:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/registry.rs:483:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/registry.rs:503:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/registry.rs:505:38: calling `util::config::CargoHttpConfig::default()` is more clear than this expression
+cargo-0.49.0/src/cargo/ops/registry.rs:510:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/registry.rs:529:5: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/ops/registry.rs:53:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/registry.rs:573:22: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/ops/registry.rs:608:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/registry.rs:621:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/registry.rs:671:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/registry.rs:671:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/ops/registry.rs:674:10: this argument is passed by value, but not consumed in the function body
+cargo-0.49.0/src/cargo/ops/registry.rs:678:17: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+cargo-0.49.0/src/cargo/ops/registry.rs:730:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/registry.rs:731:16: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+cargo-0.49.0/src/cargo/ops/registry.rs:785:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/registry.rs:794:16: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+cargo-0.49.0/src/cargo/ops/registry.rs:828:14: you should put `SourceId` between ticks in the documentation
+cargo-0.49.0/src/cargo/ops/registry.rs:848:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/resolve.rs:199:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/resolve.rs:199:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/ops/resolve.rs:199:1: this function has too many lines (137/100)
+cargo-0.49.0/src/cargo/ops/resolve.rs:241:28: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+cargo-0.49.0/src/cargo/ops/resolve.rs:28:1: item name ends with its containing module's name
+cargo-0.49.0/src/cargo/ops/resolve.rs:384:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/resolve.rs:417:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/resolve.rs:589:9: `keep` is being shadowed
+cargo-0.49.0/src/cargo/ops/resolve.rs:58:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/resolve.rs:58:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/ops/resolve.rs:602:5: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/ops/resolve.rs:75:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/resolve.rs:75:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/ops/tree/graph.rs:129:26: you should put `PackageIds` between ticks in the documentation
+cargo-0.49.0/src/cargo/ops/tree/graph.rs:131:47: called `filter(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/ops/tree/graph.rs:152:15: indexing into a vector may panic
+cargo-0.49.0/src/cargo/ops/tree/graph.rs:173:9: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/ops/tree/graph.rs:234:46: called `filter(..).flat_map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/ops/tree/graph.rs:328:44: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/ops/tree/graph.rs:330:50: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/ops/tree/graph.rs:563:35: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+cargo-0.49.0/src/cargo/ops/tree/mod.rs:112:11: literal non-ASCII character detected
+cargo-0.49.0/src/cargo/ops/tree/mod.rs:113:10: literal non-ASCII character detected
+cargo-0.49.0/src/cargo/ops/tree/mod.rs:114:10: literal non-ASCII character detected
+cargo-0.49.0/src/cargo/ops/tree/mod.rs:115:12: literal non-ASCII character detected
+cargo-0.49.0/src/cargo/ops/tree/mod.rs:126:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/tree/mod.rs:21:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/ops/tree/mod.rs:21:1: more than 3 bools in a struct
+cargo-0.49.0/src/cargo/ops/tree/mod.rs:360:30: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/ops/tree/mod.rs:58:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/ops/vendor.rs:14:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/ops/vendor.rs:21:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/ops/vendor.rs:314:34: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/ops/vendor.rs:324:13: wildcard match will miss any future added variants
+cargo-0.49.0/src/cargo/ops/vendor.rs:70:1: this function has too many lines (175/100)
+cargo-0.49.0/src/cargo/sources/config.rs:102:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/sources/config.rs:135:67: redundant closure found
+cargo-0.49.0/src/cargo/sources/config.rs:206:36: this argument is passed by value, but not consumed in the function body
+cargo-0.49.0/src/cargo/sources/config.rs:282:9: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/sources/config.rs:70:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/sources/config.rs:81:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/sources/config.rs:97:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/sources/directory.rs:14:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/sources/directory.rs:90:56: redundant closure found
+cargo-0.49.0/src/cargo/sources/git/source.rs:14:1: item name ends with its containing module's name
+cargo-0.49.0/src/cargo/sources/git/source.rs:25:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/sources/git/source.rs:49:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/sources/git/source.rs:53:5: docs for function returning `Result` missing `# Errors` section
 cargo-0.49.0/src/cargo/sources/git/source.rs:69:20: comparison to empty slice
+cargo-0.49.0/src/cargo/sources/git/utils.rs:1025:19: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
 cargo-0.49.0/src/cargo/sources/git/utils.rs:1158:9: stripping a suffix manually
+cargo-0.49.0/src/cargo/sources/git/utils.rs:176:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/sources/git/utils.rs:180:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/sources/git/utils.rs:184:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/sources/git/utils.rs:188:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/sources/git/utils.rs:242:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/sources/git/utils.rs:253:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/sources/git/utils.rs:262:13: unnecessary boolean `not` operation
+cargo-0.49.0/src/cargo/sources/git/utils.rs:289:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/sources/git/utils.rs:294:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/sources/git/utils.rs:298:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/sources/git/utils.rs:308:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/sources/git/utils.rs:472:9: non-binding `let` on a type that implements `Drop`
+cargo-0.49.0/src/cargo/sources/git/utils.rs:489:9: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/sources/git/utils.rs:503:9: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/sources/git/utils.rs:528:28: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+cargo-0.49.0/src/cargo/sources/git/utils.rs:537:21: non-binding `let` on a type that implements `Drop`
+cargo-0.49.0/src/cargo/sources/git/utils.rs:588:1: this function has too many lines (135/100)
 cargo-0.49.0/src/cargo/sources/git/utils.rs:758:9: calling `push_str()` using a single-character string literal
+cargo-0.49.0/src/cargo/sources/git/utils.rs:858:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/sources/path.rs:129:44: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/sources/path.rs:143:44: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/sources/path.rs:15:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/sources/path.rs:282:50: redundant closure found
+cargo-0.49.0/src/cargo/sources/path.rs:313:21: binding's name is too similar to existing binding
+cargo-0.49.0/src/cargo/sources/path.rs:314:21: binding's name is too similar to existing binding
+cargo-0.49.0/src/cargo/sources/path.rs:319:21: binding's name is too similar to existing binding
+cargo-0.49.0/src/cargo/sources/path.rs:339:9: adding items after statements is confusing, since items exist from the start of the scope
 cargo-0.49.0/src/cargo/sources/path.rs:339:9: this function's return value is unnecessarily wrapped by `Result`
+cargo-0.49.0/src/cargo/sources/path.rs:380:9: unused `self` argument
+cargo-0.49.0/src/cargo/sources/path.rs:419:50: redundant closure found
+cargo-0.49.0/src/cargo/sources/path.rs:429:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/sources/path.rs:460:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/sources/path.rs:473:43: redundant closure found
+cargo-0.49.0/src/cargo/sources/path.rs:482:43: redundant closure found
+cargo-0.49.0/src/cargo/sources/path.rs:63:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/sources/path.rs:77:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/sources/path.rs:98:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/sources/registry/index.rs:117:23: integer type suffix should be separated by an underscore
+cargo-0.49.0/src/cargo/sources/registry/index.rs:121:70: integer type suffix should be separated by an underscore
+cargo-0.49.0/src/cargo/sources/registry/index.rs:167:1: item name ends with its containing module's name
+cargo-0.49.0/src/cargo/sources/registry/index.rs:215:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/sources/registry/index.rs:324:23: redundant closure found
+cargo-0.49.0/src/cargo/sources/registry/index.rs:393:25: called `filter(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/sources/registry/index.rs:468:40: you should put `SourceId` between ticks in the documentation
+cargo-0.49.0/src/cargo/sources/registry/index.rs:590:9: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/sources/registry/index.rs:648:17: binding's name is too similar to existing binding
 cargo-0.49.0/src/cargo/sources/registry/index.rs:736:1: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+cargo-0.49.0/src/cargo/sources/registry/index.rs:95:37: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+cargo-0.49.0/src/cargo/sources/registry/local.rs:12:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/sources/registry/mod.rs:192:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/sources/registry/mod.rs:203:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/sources/registry/mod.rs:229:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/sources/registry/mod.rs:372:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/sources/registry/mod.rs:373:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/sources/registry/mod.rs:375:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/sources/registry/mod.rs:381:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/sources/registry/mod.rs:382:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/sources/registry/mod.rs:383:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/sources/registry/mod.rs:384:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/sources/registry/mod.rs:452:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/sources/registry/mod.rs:582:20: redundant else block
+cargo-0.49.0/src/cargo/sources/registry/mod.rs:621:9: unnecessary `!=` operation
+cargo-0.49.0/src/cargo/sources/registry/remote.rs:139:17: unused `self` argument
+cargo-0.49.0/src/cargo/sources/registry/remote.rs:32:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/sources/registry/remote.rs:72:13: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+cargo-0.49.0/src/cargo/sources/replaced.rs:12:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/sources/replaced.rs:5:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/util/canonical_url.rs:19:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/canonical_url.rs:65:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/command_prelude.rs:218:1: this function could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/command_prelude.rs:222:1: this function could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/command_prelude.rs:234:1: this function could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/command_prelude.rs:249:1: this function could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/command_prelude.rs:264:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/command_prelude.rs:279:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/command_prelude.rs:298:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/command_prelude.rs:320:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/command_prelude.rs:328:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/command_prelude.rs:352:13: unnecessary boolean `not` operation
+cargo-0.49.0/src/cargo/util/command_prelude.rs:363:13: unnecessary boolean `not` operation
+cargo-0.49.0/src/cargo/util/command_prelude.rs:378:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/command_prelude.rs:387:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/command_prelude.rs:387:5: this function has too many lines (104/100)
+cargo-0.49.0/src/cargo/util/command_prelude.rs:39:20: you should put `arg_package_spec` between ticks in the documentation
+cargo-0.49.0/src/cargo/util/command_prelude.rs:504:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/command_prelude.rs:516:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/command_prelude.rs:530:40: redundant closure found
+cargo-0.49.0/src/cargo/util/command_prelude.rs:531:43: redundant closure found
+cargo-0.49.0/src/cargo/util/command_prelude.rs:536:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/command_prelude.rs:556:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/command_prelude.rs:575:49: redundant closure found
+cargo-0.49.0/src/cargo/util/command_prelude.rs:580:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/command_prelude.rs:631:18: redundant closure found
+cargo-0.49.0/src/cargo/util/command_prelude.rs:638:18: redundant closure found
+cargo-0.49.0/src/cargo/util/command_prelude.rs:647:1: this function could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/command_prelude.rs:651:1: this function could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/command_prelude.rs:662:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/command_prelude.rs:665:51: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/util/config/de.rs:420:16: this argument is passed by value, but not consumed in the function body
+cargo-0.49.0/src/cargo/util/config/de.rs:46:25: you should put `CV::List` between ticks in the documentation
+cargo-0.49.0/src/cargo/util/config/de.rs:47:24: you should put `ConfigSeqAccess` between ticks in the documentation
+cargo-0.49.0/src/cargo/util/config/de.rs:527:53: integer type suffix should be separated by an underscore
+cargo-0.49.0/src/cargo/util/config/de.rs:530:53: integer type suffix should be separated by an underscore
+cargo-0.49.0/src/cargo/util/config/de.rs:532:68: integer type suffix should be separated by an underscore
+cargo-0.49.0/src/cargo/util/config/key.rs:11:1: item name ends with its containing module's name
 cargo-0.49.0/src/cargo/util/config/key.rs:69:9: calling `push_str()` using a single-character string literal
+cargo-0.49.0/src/cargo/util/config/mod.rs:100:71: you should put `OptValue` between ticks in the documentation
+cargo-0.49.0/src/cargo/util/config/mod.rs:100:71: you should put `OptValue` between ticks in the documentation
+cargo-0.49.0/src/cargo/util/config/mod.rs:100:71: you should put `OptValue` between ticks in the documentation
+cargo-0.49.0/src/cargo/util/config/mod.rs:1049:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:1064:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:1090:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:1166:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:1179:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:1184:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:1189:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:1203:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:1211:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:1216:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:1225:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:1229:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:124:1: more than 3 bools in a struct
+cargo-0.49.0/src/cargo/util/config/mod.rs:1254:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:1279:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:1281:9: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+cargo-0.49.0/src/cargo/util/config/mod.rs:1323:9: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/util/config/mod.rs:1339:39: unused `self` argument
+cargo-0.49.0/src/cargo/util/config/mod.rs:1344:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/util/config/mod.rs:1420:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/util/config/mod.rs:1553:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:1560:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:1567:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:1574:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:1581:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:1588:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/config/mod.rs:1598:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/config/mod.rs:1619:1: this function could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/config/mod.rs:1623:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:1623:64: this argument is passed by value, but not consumed in the function body
+cargo-0.49.0/src/cargo/util/config/mod.rs:1649:9: use Option::map_or_else instead of an if let/else
+cargo-0.49.0/src/cargo/util/config/mod.rs:1699:5: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/util/config/mod.rs:1730:1: item name ends with its containing module's name
+cargo-0.49.0/src/cargo/util/config/mod.rs:1757:1: item name ends with its containing module's name
+cargo-0.49.0/src/cargo/util/config/mod.rs:1770:1: item name ends with its containing module's name
+cargo-0.49.0/src/cargo/util/config/mod.rs:1778:1: item name ends with its containing module's name
+cargo-0.49.0/src/cargo/util/config/mod.rs:1804:1: item name ends with its containing module's name
+cargo-0.49.0/src/cargo/util/config/mod.rs:1896:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/config/mod.rs:1901:5: you should put `StringList` between ticks in the documentation
+cargo-0.49.0/src/cargo/util/config/mod.rs:214:13: wildcard match will miss any future added variants
+cargo-0.49.0/src/cargo/util/config/mod.rs:259:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:298:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:311:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:318:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:353:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:401:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:411:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:419:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:431:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:449:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:454:16: use Option::map_or instead of an if let/else
+cargo-0.49.0/src/cargo/util/config/mod.rs:547:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:556:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:582:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:595:20: you should put `StringList` between ticks in the documentation
+cargo-0.49.0/src/cargo/util/config/mod.rs:689:20: unused `self` argument
+cargo-0.49.0/src/cargo/util/config/mod.rs:699:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:699:5: more than 3 bools in function parameters
+cargo-0.49.0/src/cargo/util/config/mod.rs:719:58: redundant closure found
+cargo-0.49.0/src/cargo/util/config/mod.rs:816:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/config/mod.rs:875:36: binding's name is too similar to existing binding
+cargo-0.49.0/src/cargo/util/config/mod.rs:876:37: binding's name is too similar to existing binding
+cargo-0.49.0/src/cargo/util/config/path.rs:10:1: item name ends with its containing module's name
+cargo-0.49.0/src/cargo/util/config/path.rs:14:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/config/path.rs:48:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/util/config/target.rs:12:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/util/config/target.rs:24:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/util/config/value.rs:29:1: item name ends with its containing module's name
+cargo-0.49.0/src/cargo/util/config/value.rs:80:5: this method could have a `#[must_use]` attribute
 cargo-0.49.0/src/cargo/util/config/value.rs:81:9: match expression looks like `matches!` macro
+cargo-0.49.0/src/cargo/util/cpu.rs:11:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/cpu.rs:22:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/cpu.rs:82:25: casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+cargo-0.49.0/src/cargo/util/cpu.rs:82:9: casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+cargo-0.49.0/src/cargo/util/dependency_queue.rs:109:27: redundant closure found
+cargo-0.49.0/src/cargo/util/dependency_queue.rs:136:20: called `filter(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/util/dependency_queue.rs:151:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/dependency_queue.rs:156:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/dependency_queue.rs:46:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/dependency_queue.rs:91:9: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/util/diagnostic_server.rs:218:1: item name ends with its containing module's name
+cargo-0.49.0/src/cargo/util/diagnostic_server.rs:230:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/diagnostic_server.rs:242:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/diagnostic_server.rs:58:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/diagnostic_server.rs:96:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/diagnostic_server.rs:96:5: this function has too many lines (110/100)
+cargo-0.49.0/src/cargo/util/diagnostic_server.rs:99:21: `msg` is being shadowed
+cargo-0.49.0/src/cargo/util/errors.rs:101:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/errors.rs:143:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/errors.rs:150:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/errors.rs:15:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/errors.rs:237:5: variant name ends with the enum's name
+cargo-0.49.0/src/cargo/util/errors.rs:245:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/errors.rs:321:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/errors.rs:328:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/errors.rs:356:1: this function could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/errors.rs:391:5: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/util/errors.rs:392:13: usage of wildcard import
+cargo-0.49.0/src/cargo/util/errors.rs:465:1: this function could have a `#[must_use]` attribute
 cargo-0.49.0/src/cargo/util/errors.rs:473:5: manual `RangeInclusive::contains` implementation
+cargo-0.49.0/src/cargo/util/errors.rs:66:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/flock.rs:115:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/flock.rs:11:5: usage of wildcard import
+cargo-0.49.0/src/cargo/util/flock.rs:134:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/flock.rs:142:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/flock.rs:150:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/flock.rs:156:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/flock.rs:170:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/flock.rs:192:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/flock.rs:29:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/flock.rs:321:5: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/util/flock.rs:335:23: casting `i64` to `u32` may lose the sign of the value
+cargo-0.49.0/src/cargo/util/flock.rs:335:23: casting `i64` to `u32` may truncate the value
+cargo-0.49.0/src/cargo/util/flock.rs:335:44: casting `i64` to `u32` may truncate the value
+cargo-0.49.0/src/cargo/util/flock.rs:379:35: this `match` has identical arm bodies
+cargo-0.49.0/src/cargo/util/flock.rs:37:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/flock.rs:43:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/flock.rs:52:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/graph.rs:10:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/graph.rs:115:13: called `find(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/util/graph.rs:41:51: redundant closure found
+cargo-0.49.0/src/cargo/util/graph.rs:45:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/graph.rs:95:13: called `find(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/util/hasher.rs:12:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/hasher.rs:9:1: item name ends with its containing module's name
+cargo-0.49.0/src/cargo/util/hex.rs:10:9: casting `u64` to `u8` may truncate the value
+cargo-0.49.0/src/cargo/util/hex.rs:11:9: casting `u64` to `u8` may truncate the value
+cargo-0.49.0/src/cargo/util/hex.rs:12:9: casting `u64` to `u8` may truncate the value
+cargo-0.49.0/src/cargo/util/hex.rs:13:9: casting `u64` to `u8` may truncate the value
+cargo-0.49.0/src/cargo/util/hex.rs:14:9: casting `u64` to `u8` may truncate the value
+cargo-0.49.0/src/cargo/util/hex.rs:15:9: casting `u64` to `u8` may truncate the value
+cargo-0.49.0/src/cargo/util/hex.rs:25:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/hex.rs:6:1: item name ends with its containing module's name
+cargo-0.49.0/src/cargo/util/hex.rs:6:1: this function could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/hex.rs:8:9: casting `u64` to `u8` may truncate the value
+cargo-0.49.0/src/cargo/util/hex.rs:9:9: casting `u64` to `u8` may truncate the value
+cargo-0.49.0/src/cargo/util/important_paths.rs:23:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/important_paths.rs:6:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/interning.rs:66:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/interning.rs:77:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/into_url.rs:10:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/into_url_with_base.rs:9:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/job.rs:20:1: this function could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/lev_distance.rs:3:1: this function could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/lockserver.rs:111:32: redundant else block
+cargo-0.49.0/src/cargo/util/lockserver.rs:158:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/lockserver.rs:46:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/lockserver.rs:58:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/lockserver.rs:62:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/mod.rs:68:1: this function could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/mod.rs:79:1: this function could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/network.rs:12:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/network.rs:19:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/network.rs:84:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/paths.rs:109:12: redundant else block
+cargo-0.49.0/src/cargo/util/paths.rs:114:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/paths.rs:121:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/paths.rs:125:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/paths.rs:130:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/paths.rs:14:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/paths.rs:14:1: item name ends with its containing module's name
+cargo-0.49.0/src/cargo/util/paths.rs:151:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/paths.rs:167:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/paths.rs:173:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/paths.rs:178:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/paths.rs:185:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/paths.rs:199:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/paths.rs:215:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/paths.rs:228:1: this function could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/paths.rs:251:9: use Option::map_or instead of an if let/else
+cargo-0.49.0/src/cargo/util/paths.rs:267:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/paths.rs:276:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/paths.rs:29:1: this function could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/paths.rs:303:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/paths.rs:312:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/paths.rs:346:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/paths.rs:415:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/paths.rs:445:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/paths.rs:459:45: redundant closure found
+cargo-0.49.0/src/cargo/util/paths.rs:469:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/paths.rs:54:1: this function could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/paths.rs:61:1: this function could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/paths.rs:63:19: use Option::map_or_else instead of an if let/else
+cargo-0.49.0/src/cargo/util/paths.rs:88:1: docs for function returning `Result` missing `# Errors` section
 cargo-0.49.0/src/cargo/util/paths.rs:93:31: comparison to empty slice
+cargo-0.49.0/src/cargo/util/process_builder.rs:106:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/process_builder.rs:111:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/process_builder.rs:122:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/process_builder.rs:132:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/process_builder.rs:152:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/process_builder.rs:185:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/process_builder.rs:190:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/process_builder.rs:218:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/process_builder.rs:307:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/process_builder.rs:343:39: this argument is passed by value, but not consumed in the function body
+cargo-0.49.0/src/cargo/util/progress.rs:122:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/progress.rs:136:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/progress.rs:15:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/util/progress.rs:249:19: casting `usize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`usize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+cargo-0.49.0/src/cargo/util/progress.rs:249:34: casting `usize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`usize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+cargo-0.49.0/src/cargo/util/progress.rs:250:19: unnecessary boolean `not` operation
+cargo-0.49.0/src/cargo/util/progress.rs:263:22: casting `usize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`usize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+cargo-0.49.0/src/cargo/util/progress.rs:264:22: casting `f64` to `usize` may lose the sign of the value
+cargo-0.49.0/src/cargo/util/progress.rs:264:22: casting `f64` to `usize` may truncate the value
 cargo-0.49.0/src/cargo/util/progress.rs:269:17: calling `push_str()` using a single-character string literal
 cargo-0.49.0/src/cargo/util/progress.rs:272:17: calling `push_str()` using a single-character string literal
 cargo-0.49.0/src/cargo/util/progress.rs:274:17: calling `push_str()` using a single-character string literal
 cargo-0.49.0/src/cargo/util/progress.rs:280:13: calling `push_str()` using a single-character string literal
 cargo-0.49.0/src/cargo/util/progress.rs:282:9: calling `push_str()` using a single-character string literal
+cargo-0.49.0/src/cargo/util/progress.rs:89:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/progress.rs:97:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/queue.rs:25:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/read2.rs:11:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/read2.rs:31:17: binding's name is too similar to existing binding
+cargo-0.49.0/src/cargo/util/restricted_names.rs:13:1: this function could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/restricted_names.rs:26:1: this function could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/restricted_names.rs:35:1: this function could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/restricted_names.rs:45:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/restricted_names.rs:87:1: this function could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/restricted_names.rs:89:21: redundant closure found
+cargo-0.49.0/src/cargo/util/restricted_names.rs:8:1: this function could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/rustc.rs:103:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/rustc.rs:114:5: you should put bare URLs between `<`/`>` or make a proper Markdown link
+cargo-0.49.0/src/cargo/util/rustc.rs:115:5: you should put bare URLs between `<`/`>` or make a proper Markdown link
+cargo-0.49.0/src/cargo/util/rustc.rs:162:17: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/util/rustc.rs:39:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/rustc.rs:55:13: called `find(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/util/sha256.rs:10:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/sha256.rs:20:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/sha256.rs:31:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/sha256.rs:40:24: integer type suffix should be separated by an underscore
+cargo-0.49.0/src/cargo/util/to_semver.rs:5:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/toml/mod.rs:1005:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/toml/mod.rs:1005:5: this function has too many lines (282/100)
+cargo-0.49.0/src/cargo/util/toml/mod.rs:1094:36: redundant closure found
+cargo-0.49.0/src/cargo/util/toml/mod.rs:1121:13: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/util/toml/mod.rs:1197:32: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
+cargo-0.49.0/src/cargo/util/toml/mod.rs:124:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/toml/mod.rs:1504:9: unused `self` argument
+cargo-0.49.0/src/cargo/util/toml/mod.rs:1526:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/toml/mod.rs:1582:19: calling `util::toml::DetailedTomlDependency::default()` is more clear than this expression
+cargo-0.49.0/src/cargo/util/toml/mod.rs:1598:5: this function has too many lines (153/100)
 cargo-0.49.0/src/cargo/util/toml/mod.rs:1687:33: unnecessary closure used to substitute value for `Option::None`
+cargo-0.49.0/src/cargo/util/toml/mod.rs:178:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/util/toml/mod.rs:248:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/util/toml/mod.rs:274:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/util/toml/mod.rs:277:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/toml/mod.rs:281:5: this method could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/toml/mod.rs:285:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/toml/mod.rs:294:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/util/toml/mod.rs:31:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/toml/mod.rs:381:35: casting `i64` to `u32` may lose the sign of the value
+cargo-0.49.0/src/cargo/util/toml/mod.rs:381:35: casting `i64` to `u32` may truncate the value
+cargo-0.49.0/src/cargo/util/toml/mod.rs:388:35: casting `u64` to `u32` may truncate the value
+cargo-0.49.0/src/cargo/util/toml/mod.rs:398:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/util/toml/mod.rs:450:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/toml/mod.rs:536:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/toml/mod.rs:783:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/util/toml/mod.rs:824:1: item name starts with its containing module's name
+cargo-0.49.0/src/cargo/util/toml/mod.rs:834:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/toml/mod.rs:83:42: redundant closure found
+cargo-0.49.0/src/cargo/util/toml/mod.rs:852:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/toml/mod.rs:852:5: this function has too many lines (138/100)
+cargo-0.49.0/src/cargo/util/toml/mod.rs:962:9: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/util/toml/mod.rs:971:24: called `filter(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/util/toml/mod.rs:979:9: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/util/toml/mod.rs:98:5: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/util/toml/mod.rs:999:23: calling `util::toml::DetailedTomlDependency::default()` is more clear than this expression
+cargo-0.49.0/src/cargo/util/toml/targets.rs:112:27: redundant closure found
+cargo-0.49.0/src/cargo/util/toml/targets.rs:325:5: adding items after statements is confusing, since items exist from the start of the scope
+cargo-0.49.0/src/cargo/util/toml/targets.rs:586:21: redundant closure found
+cargo-0.49.0/src/cargo/util/toml/targets.rs:593:42: redundant closure found
+cargo-0.49.0/src/cargo/util/toml/targets.rs:605:19: redundant closure found
+cargo-0.49.0/src/cargo/util/toml/targets.rs:612:42: redundant closure found
+cargo-0.49.0/src/cargo/util/toml/targets.rs:756:36: redundant closure found
+cargo-0.49.0/src/cargo/util/toml/targets.rs:810:24: called `filter(..).map(..)` on an `Iterator`
+cargo-0.49.0/src/cargo/util/vcs.rs:10:1: this function could have a `#[must_use]` attribute
+cargo-0.49.0/src/cargo/util/vcs.rs:33:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/vcs.rs:37:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/vcs.rs:43:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/vcs.rs:47:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/vcs.rs:59:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/vcs.rs:66:5: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/workspace.rs:52:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/workspace.rs:56:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/workspace.rs:60:1: docs for function returning `Result` missing `# Errors` section
+cargo-0.49.0/src/cargo/util/workspace.rs:64:1: docs for function returning `Result` missing `# Errors` section
+iron-0.6.1/src/error.rs:24:1: item name ends with its containing module's name
 iron-0.6.1/src/error.rs:55:20: use of deprecated associated function `std::error::Error::description`: use the Display impl or to_string()
 iron-0.6.1/src/iron.rs:105:13: redundant field names in struct initialization
+iron-0.6.1/src/iron.rs:119:5: docs for function returning `Result` missing `# Errors` section
+iron-0.6.1/src/iron.rs:133:5: docs for function returning `Result` missing `# Errors` section
+iron-0.6.1/src/iron.rs:143:5: docs for function returning `Result` missing `# Errors` section
 iron-0.6.1/src/iron.rs:148:19: use of deprecated macro `try`: use the `?` operator instead
 iron-0.6.1/src/iron.rs:149:13: redundant field names in struct initialization
+iron-0.6.1/src/iron.rs:167:49: binding's name is too similar to existing binding
+iron-0.6.1/src/iron.rs:80:5: this method could have a `#[must_use]` attribute
+iron-0.6.1/src/iron.rs:85:5: this method could have a `#[must_use]` attribute
+iron-0.6.1/src/iron.rs:90:5: this method could have a `#[must_use]` attribute
+iron-0.6.1/src/middleware/mod.rs:137:5: docs for function returning `Result` missing `# Errors` section
+iron-0.6.1/src/middleware/mod.rs:150:1: item name ends with its containing module's name
+iron-0.6.1/src/middleware/mod.rs:152:5: docs for function returning `Result` missing `# Errors` section
+iron-0.6.1/src/middleware/mod.rs:159:5: docs for function returning `Result` missing `# Errors` section
+iron-0.6.1/src/middleware/mod.rs:171:1: item name ends with its containing module's name
+iron-0.6.1/src/middleware/mod.rs:173:5: docs for function returning `Result` missing `# Errors` section
+iron-0.6.1/src/middleware/mod.rs:182:5: docs for function returning `Result` missing `# Errors` section
+iron-0.6.1/src/middleware/mod.rs:192:1: item name ends with its containing module's name
+iron-0.6.1/src/middleware/mod.rs:217:25: you should put `ChainBuilder` between ticks in the documentation
+iron-0.6.1/src/middleware/mod.rs:328:20: binding's name is too similar to existing binding
+iron-0.6.1/src/middleware/mod.rs:360:16: binding's name is too similar to existing binding
+iron-0.6.1/src/middleware/mod.rs:368:33: binding's name is too similar to existing binding
+iron-0.6.1/src/middleware/mod.rs:428:40: binding's name is too similar to existing binding
+iron-0.6.1/src/middleware/mod.rs:434:40: binding's name is too similar to existing binding
+iron-0.6.1/src/middleware/mod.rs:444:40: binding's name is too similar to existing binding
 iron-0.6.1/src/modifiers.rs:132:14: use of `expect` followed by a function call
+iron-0.6.1/src/request/mod.rs:113:24: binding's name is too similar to existing binding
 iron-0.6.1/src/request/mod.rs:121:13: redundant field names in struct initialization
 iron-0.6.1/src/request/mod.rs:123:13: redundant field names in struct initialization
 iron-0.6.1/src/request/mod.rs:124:13: redundant field names in struct initialization
 iron-0.6.1/src/request/mod.rs:126:13: redundant field names in struct initialization
 iron-0.6.1/src/request/mod.rs:128:13: redundant field names in struct initialization
+iron-0.6.1/src/request/mod.rs:153:69: you should put `HttpReader` between ticks in the documentation
+iron-0.6.1/src/request/mod.rs:154:5: this method could have a `#[must_use]` attribute
 iron-0.6.1/src/request/mod.rs:32:1: this seems like a manual implementation of the non-exhaustive pattern
 iron-0.6.1/src/request/mod.rs:62:9: use of deprecated macro `try`: use the `?` operator instead
 iron-0.6.1/src/request/mod.rs:64:9: use of deprecated macro `try`: use the `?` operator instead
@@ -56,83 +1414,231 @@ iron-0.6.1/src/request/mod.rs:65:9: use of deprecated macro `try`: use the `?` o
 iron-0.6.1/src/request/mod.rs:66:9: use of deprecated macro `try`: use the `?` operator instead
 iron-0.6.1/src/request/mod.rs:67:9: use of deprecated macro `try`: use the `?` operator instead
 iron-0.6.1/src/request/mod.rs:69:9: use of deprecated macro `try`: use the `?` operator instead
+iron-0.6.1/src/request/mod.rs:75:34: you should put `HttpRequest` between ticks in the documentation
+iron-0.6.1/src/request/mod.rs:77:39: you should put `HttpRequest` between ticks in the documentation
+iron-0.6.1/src/request/mod.rs:78:5: docs for function returning `Result` missing `# Errors` section
+iron-0.6.1/src/request/mod.rs:82:13: binding's name is too similar to existing binding
+iron-0.6.1/src/request/mod.rs:83:29: binding's name is too similar to existing binding
+iron-0.6.1/src/request/mod.rs:85:24: binding's name is too similar to existing binding
+iron-0.6.1/src/request/url.rs:109:5: this method could have a `#[must_use]` attribute
+iron-0.6.1/src/request/url.rs:117:5: this method could have a `#[must_use]` attribute
 iron-0.6.1/src/request/url.rs:124:9: use of deprecated macro `try`: use the `?` operator instead
+iron-0.6.1/src/request/url.rs:21:14: you should put bare URLs between `<`/`>` or make a proper Markdown link
+iron-0.6.1/src/request/url.rs:22:5: docs for function returning `Result` missing `# Errors` section
+iron-0.6.1/src/request/url.rs:31:5: docs for function returning `Result` missing `# Errors` section
+iron-0.6.1/src/request/url.rs:47:5: this method could have a `#[must_use]` attribute
+iron-0.6.1/src/request/url.rs:52:5: this method could have a `#[must_use]` attribute
+iron-0.6.1/src/request/url.rs:57:5: this method could have a `#[must_use]` attribute
+iron-0.6.1/src/request/url.rs:63:5: this method could have a `#[must_use]` attribute
+iron-0.6.1/src/request/url.rs:73:5: this method could have a `#[must_use]` attribute
+iron-0.6.1/src/request/url.rs:83:5: this method could have a `#[must_use]` attribute
+iron-0.6.1/src/request/url.rs:96:5: this method could have a `#[must_use]` attribute
+iron-0.6.1/src/response.rs:121:19: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+iron-0.6.1/src/response.rs:125:43: redundant closure found
+iron-0.6.1/src/response.rs:139:41: redundant closure found
 iron-0.6.1/src/response.rs:142:23: use of deprecated macro `try`: use the `?` operator instead
 iron-0.6.1/src/response.rs:143:5: use of deprecated macro `try`: use the `?` operator instead
+iron-0.6.1/src/response.rs:24:5: docs for function returning `Result` missing `# Errors` section
+iron-0.6.1/src/response.rs:95:5: this method could have a `#[must_use]` attribute
 iron-0.6.1/src/response.rs:95:5: you should consider adding a `Default` implementation for `response::Response`
 ripgrep-12.1.1/build.rs:133:19: called `.as_ref().map(|x| &**x)` on an Option value. This can be done more directly by calling `githash.as_deref()` instead
+ripgrep-12.1.1/build.rs:18:18: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+ripgrep-12.1.1/build.rs:225:14: redundant closure found
 ripgrep-12.1.1/build.rs:92:19: called `.as_ref().map(|x| &**x)` on an Option value. This can be done more directly by calling `githash.as_deref()` instead
+ripgrep-12.1.1/crates/core/app.rs:1408:5: adding items after statements is confusing, since items exist from the start of the scope
+ripgrep-12.1.1/crates/core/app.rs:1408:5: adding items after statements is confusing, since items exist from the start of the scope
+ripgrep-12.1.1/crates/core/app.rs:1409:5: adding items after statements is confusing, since items exist from the start of the scope
+ripgrep-12.1.1/crates/core/app.rs:1409:5: adding items after statements is confusing, since items exist from the start of the scope
+ripgrep-12.1.1/crates/core/app.rs:152:32: you should put `clap::Arg` between ticks in the documentation
+ripgrep-12.1.1/crates/core/app.rs:152:32: you should put `clap::Arg` between ticks in the documentation
+ripgrep-12.1.1/crates/core/app.rs:156:39: you should put `clap::Arg` between ticks in the documentation
+ripgrep-12.1.1/crates/core/app.rs:156:39: you should put `clap::Arg` between ticks in the documentation
+ripgrep-12.1.1/crates/core/app.rs:156:5: you should put `RGArg` between ticks in the documentation
+ripgrep-12.1.1/crates/core/app.rs:156:5: you should put `RGArg` between ticks in the documentation
+ripgrep-12.1.1/crates/core/app.rs:1668:5: adding items after statements is confusing, since items exist from the start of the scope
+ripgrep-12.1.1/crates/core/app.rs:1668:5: adding items after statements is confusing, since items exist from the start of the scope
+ripgrep-12.1.1/crates/core/app.rs:1669:5: adding items after statements is confusing, since items exist from the start of the scope
+ripgrep-12.1.1/crates/core/app.rs:1669:5: adding items after statements is confusing, since items exist from the start of the scope
+ripgrep-12.1.1/crates/core/app.rs:1821:5: adding items after statements is confusing, since items exist from the start of the scope
+ripgrep-12.1.1/crates/core/app.rs:1821:5: adding items after statements is confusing, since items exist from the start of the scope
+ripgrep-12.1.1/crates/core/app.rs:1822:5: adding items after statements is confusing, since items exist from the start of the scope
+ripgrep-12.1.1/crates/core/app.rs:1822:5: adding items after statements is confusing, since items exist from the start of the scope
+ripgrep-12.1.1/crates/core/app.rs:2999:5: adding items after statements is confusing, since items exist from the start of the scope
+ripgrep-12.1.1/crates/core/app.rs:2999:5: adding items after statements is confusing, since items exist from the start of the scope
+ripgrep-12.1.1/crates/core/app.rs:3000:5: adding items after statements is confusing, since items exist from the start of the scope
+ripgrep-12.1.1/crates/core/app.rs:3000:5: adding items after statements is confusing, since items exist from the start of the scope
+ripgrep-12.1.1/crates/core/app.rs:367:54: this `match` has identical arm bodies
+ripgrep-12.1.1/crates/core/app.rs:367:54: this `match` has identical arm bodies
+ripgrep-12.1.1/crates/core/app.rs:414:59: this `match` has identical arm bodies
+ripgrep-12.1.1/crates/core/app.rs:414:59: this `match` has identical arm bodies
+ripgrep-12.1.1/crates/core/app.rs:417:57: this `match` has identical arm bodies
+ripgrep-12.1.1/crates/core/app.rs:417:57: this `match` has identical arm bodies
+ripgrep-12.1.1/crates/core/app.rs:417:57: this `match` has identical arm bodies
+ripgrep-12.1.1/crates/core/app.rs:417:57: this `match` has identical arm bodies
+ripgrep-12.1.1/crates/core/app.rs:444:41: this `match` has identical arm bodies
+ripgrep-12.1.1/crates/core/app.rs:444:41: this `match` has identical arm bodies
+ripgrep-12.1.1/crates/core/app.rs:470:41: this `match` has identical arm bodies
+ripgrep-12.1.1/crates/core/app.rs:470:41: this `match` has identical arm bodies
+ripgrep-12.1.1/crates/core/app.rs:75:9: you should put `RIPGREP_BUILD_GIT_HASH` between ticks in the documentation
+ripgrep-12.1.1/crates/core/app.rs:75:9: you should put `RIPGREP_BUILD_GIT_HASH` between ticks in the documentation
+ripgrep-12.1.1/crates/core/app.rs:87:5: unnecessary boolean `not` operation
+ripgrep-12.1.1/crates/core/app.rs:87:5: unnecessary boolean `not` operation
+ripgrep-12.1.1/crates/core/args.rs:1143:22: unused `self` argument
 ripgrep-12.1.1/crates/core/args.rs:11:1: this import is redundant
 ripgrep-12.1.1/crates/core/args.rs:1209:74: this `if` has identical blocks
 ripgrep-12.1.1/crates/core/args.rs:1209:74: this `if` has identical blocks
+ripgrep-12.1.1/crates/core/args.rs:1282:13: binding's name is too similar to existing binding
+ripgrep-12.1.1/crates/core/args.rs:1430:22: unused `self` argument
+ripgrep-12.1.1/crates/core/args.rs:1438:21: you should put `OsStr` between ticks in the documentation
+ripgrep-12.1.1/crates/core/args.rs:1520:44: redundant closure found
 ripgrep-12.1.1/crates/core/args.rs:1524:5: this function's return value is unnecessarily wrapped by `Result`
+ripgrep-12.1.1/crates/core/args.rs:1635:14: you should put `values_of_lossy` between ticks in the documentation
+ripgrep-12.1.1/crates/core/args.rs:1693:41: redundant closure found
+ripgrep-12.1.1/crates/core/args.rs:1770:17: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
+ripgrep-12.1.1/crates/core/args.rs:287:13: binding's name is too similar to existing binding
 ripgrep-12.1.1/crates/core/args.rs:33:1: this import is redundant
 ripgrep-12.1.1/crates/core/args.rs:34:1: this import is redundant
 ripgrep-12.1.1/crates/core/args.rs:35:1: this import is redundant
+ripgrep-12.1.1/crates/core/args.rs:410:14: this argument (2 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+ripgrep-12.1.1/crates/core/args.rs:475:18: this `match` has identical arm bodies
+ripgrep-12.1.1/crates/core/args.rs:512:19: you should put `ArgMatches` between ticks in the documentation
 ripgrep-12.1.1/crates/core/args.rs:549:16: methods called `to_*` usually take self by reference; consider choosing a less ambiguous name
+ripgrep-12.1.1/crates/core/args.rs:76:18: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+ripgrep-12.1.1/crates/core/args.rs:77:13: usage of wildcard import for enum variants
+ripgrep-12.1.1/crates/core/args.rs:923:42: you should put `BinaryDetection::quit` between ticks in the documentation
 ripgrep-12.1.1/crates/core/config.rs:13:1: this import is redundant
 ripgrep-12.1.1/crates/core/config.rs:58:6: very complex type used. Consider factoring parts into `type` definitions
 ripgrep-12.1.1/crates/core/config.rs:79:6: very complex type used. Consider factoring parts into `type` definitions
+ripgrep-12.1.1/crates/core/logger.rs:11:30: you should put `max_level` between ticks in the documentation
 ripgrep-12.1.1/crates/core/logger.rs:15:16: constants have by default a `'static` lifetime
+ripgrep-12.1.1/crates/core/main.rs:55:19: this argument is passed by value, but not consumed in the function body
+ripgrep-12.1.1/crates/core/main.rs:56:9: usage of wildcard import for enum variants
+ripgrep-12.1.1/crates/core/messages.rs:46:1: item name ends with its containing module's name
+ripgrep-12.1.1/crates/core/messages.rs:51:1: item name ends with its containing module's name
+ripgrep-12.1.1/crates/core/messages.rs:62:1: item name ends with its containing module's name
+ripgrep-12.1.1/crates/core/path_printer.rs:27:1: item name starts with its containing module's name
+ripgrep-12.1.1/crates/core/path_printer.rs:89:9: unnecessary boolean `not` operation
+ripgrep-12.1.1/crates/core/search.rs:185:1: item name starts with its containing module's name
 ripgrep-12.1.1/crates/core/search.rs:292:9: using `write!()` with a format string that ends in a single newline
+ripgrep-12.1.1/crates/core/search.rs:311:1: item name starts with its containing module's name
 ripgrep-12.1.1/crates/core/search.rs:377:12: this boolean expression can be simplified
+ripgrep-12.1.1/crates/core/search.rs:423:13: usage of wildcard import for enum variants
+ripgrep-12.1.1/crates/core/search.rs:447:13: usage of wildcard import for enum variants
 ripgrep-12.1.1/crates/core/search.rs:472:24: you are using an explicit closure for cloning elements
+ripgrep-12.1.1/crates/core/search.rs:472:41: redundant closure found
 ripgrep-12.1.1/crates/core/search.rs:480:24: you are using an explicit closure for cloning elements
+ripgrep-12.1.1/crates/core/search.rs:480:41: redundant closure found
+ripgrep-12.1.1/crates/core/search.rs:49:1: item name starts with its containing module's name
 ripgrep-12.1.1/crates/core/search.rs:509:24: you are using an explicit closure for cloning elements
+ripgrep-12.1.1/crates/core/search.rs:509:41: redundant closure found
 ripgrep-12.1.1/crates/core/search.rs:517:24: you are using an explicit closure for cloning elements
+ripgrep-12.1.1/crates/core/search.rs:517:41: redundant closure found
+ripgrep-12.1.1/crates/core/search.rs:533:36: casting `u32` to `f64` may become silently lossy if you later change the type
+ripgrep-12.1.1/crates/core/search.rs:533:5: casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+ripgrep-12.1.1/crates/core/subject.rs:20:1: item name starts with its containing module's name
 ripgrep-12.1.1/crates/core/subject.rs:4:1: this import is redundant
-tokei-12.0.4/src/cli_utils.rs:154:25: this lifetime isn't used in the function definition
-tokei-12.0.4/src/cli_utils.rs:154:29: this lifetime isn't used in the function definition
-tokei-12.0.4/src/cli_utils.rs:195:47: useless use of `format!`
-tokei-12.0.4/src/cli_utils.rs:306:47: useless use of `format!`
-tokei-12.0.4/src/config.rs:102:36: use of `or` followed by a function call
-tokei-12.0.4/src/config.rs:103:38: use of `or` followed by a function call
-tokei-12.0.4/src/config.rs:106:18: use of `or` followed by a function call
-tokei-12.0.4/src/config.rs:109:18: use of `or` followed by a function call
-tokei-12.0.4/src/config.rs:112:18: use of `or` followed by a function call
-tokei-12.0.4/src/config.rs:97:18: use of `or` followed by a function call
-tokei-12.0.4/src/config.rs:99:86: use of `or` followed by a function call
-tokei-12.0.4/src/language/language_type.rs:75:22: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `slice`
-tokei-12.0.4/src/language/syntax.rs:334:45: this `if` has identical blocks
-tokei-12.0.4/src/language/syntax.rs:334:45: this `if` has identical blocks
-tokei-12.0.4/src/language/syntax.rs:336:39: this `if` has identical blocks
-tokei-12.0.4/src/language/syntax.rs:338:16: this if-then-else expression returns a bool literal
-tokei-12.0.4/src/language/syntax.rs:338:43: this `if` has identical blocks
-tokei-12.0.4/src/language/syntax.rs:446:74: trivial regex
-tokei-12.0.4/src/language/syntax.rs:449:73: trivial regex
-tokei-12.0.4/src/language/syntax.rs:453:45: trivial regex
-tokei-12.0.4/src/utils/fs.rs:105:26: called `.as_ref().map(|v| &**v)` on an Option value. This can be done more directly by calling `config.types.as_deref()` instead
+xsv-0.13.0/src/cmd/cat.rs:101:34: redundant closure found
+xsv-0.13.0/src/cmd/cat.rs:42:1: more than 3 bools in a struct
+xsv-0.13.0/src/cmd/cat.rs:53:9: binding's name is too similar to existing binding
 xsv-0.13.0/src/cmd/cat.rs:7:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/count.rs:32:9: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/count.rs:38:9: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+xsv-0.13.0/src/cmd/count.rs:42:33: integer type suffix should be separated by an underscore
 xsv-0.13.0/src/cmd/count.rs:50:5: passing a unit value to a function
 xsv-0.13.0/src/cmd/count.rs:7:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/fixlengths.rs:45:9: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/fixlengths.rs:50:18: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+xsv-0.13.0/src/cmd/fixlengths.rs:62:30: integer type suffix should be separated by an underscore
 xsv-0.13.0/src/cmd/fixlengths.rs:9:16: statics have by default a `'static` lifetime
 xsv-0.13.0/src/cmd/flatten.rs:10:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/flatten.rs:51:9: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/fmt.rs:50:9: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/fmt.rs:55:13: binding's name is too similar to existing binding
 xsv-0.13.0/src/cmd/fmt.rs:7:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/frequency.rs:148:43: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
+xsv-0.13.0/src/cmd/frequency.rs:149:43: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
 xsv-0.13.0/src/cmd/frequency.rs:15:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/frequency.rs:169:13: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/frequency.rs:176:17: unnecessary boolean `not` operation
 xsv-0.13.0/src/cmd/frequency.rs:178:24: this `else { if .. }` block can be collapsed
+xsv-0.13.0/src/cmd/frequency.rs:77:9: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/frequency.rs:93:31: it is more concise to loop over containers instead of using explicit iteration methods
+xsv-0.13.0/src/cmd/headers.rs:43:9: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/headers.rs:49:17: it is more concise to loop over containers instead of using explicit iteration methods
 xsv-0.13.0/src/cmd/headers.rs:60:22: trait objects without an explicit `dyn` are deprecated
 xsv-0.13.0/src/cmd/headers.rs:9:16: statics have by default a `'static` lifetime
 xsv-0.13.0/src/cmd/index.rs:11:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/index.rs:45:9: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/input.rs:42:9: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/input.rs:47:9: binding's name is too similar to existing binding
 xsv-0.13.0/src/cmd/input.rs:7:16: statics have by default a `'static` lifetime
 xsv-0.13.0/src/cmd/join.rs:17:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/join.rs:194:29: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/join.rs:224:22: binding's name is too similar to existing binding
 xsv-0.13.0/src/cmd/join.rs:281:44: trait objects without an explicit `dyn` are deprecated
+xsv-0.13.0/src/cmd/join.rs:293:14: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/join.rs:293:20: binding's name is too similar to existing binding
 xsv-0.13.0/src/cmd/join.rs:297:13: redundant field names in struct initialization
 xsv-0.13.0/src/cmd/join.rs:298:13: redundant field names in struct initialization
 xsv-0.13.0/src/cmd/join.rs:299:13: redundant field names in struct initialization
 xsv-0.13.0/src/cmd/join.rs:300:13: redundant field names in struct initialization
+xsv-0.13.0/src/cmd/join.rs:308:9: unused `self` argument
+xsv-0.13.0/src/cmd/join.rs:342:38: integer type suffix should be separated by an underscore
+xsv-0.13.0/src/cmd/join.rs:342:46: integer type suffix should be separated by an underscore
+xsv-0.13.0/src/cmd/join.rs:347:9: unnecessary boolean `not` operation
+xsv-0.13.0/src/cmd/join.rs:372:44: redundant closure found
+xsv-0.13.0/src/cmd/join.rs:375:33: binding's name is too similar to existing binding
 xsv-0.13.0/src/cmd/join.rs:392:13: redundant field names in struct initialization
+xsv-0.13.0/src/cmd/join.rs:403:29: it is more concise to loop over containers instead of using explicit iteration methods
+xsv-0.13.0/src/cmd/join.rs:426:13: unnecessary boolean `not` operation
+xsv-0.13.0/src/cmd/join.rs:77:1: more than 3 bools in a struct
+xsv-0.13.0/src/cmd/join.rs:94:9: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/partition.rs:105:22: binding's name is too similar to existing binding
 xsv-0.13.0/src/cmd/partition.rs:126:36: trait objects without an explicit `dyn` are deprecated
 xsv-0.13.0/src/cmd/partition.rs:139:13: redundant field names in struct initialization
 xsv-0.13.0/src/cmd/partition.rs:15:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/partition.rs:169:9: unnecessary boolean `not` operation
+xsv-0.13.0/src/cmd/partition.rs:56:9: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/partition.rs:77:9: unused `self` argument
+xsv-0.13.0/src/cmd/sample.rs:105:44: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
+xsv-0.13.0/src/cmd/sample.rs:115:21: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
 xsv-0.13.0/src/cmd/sample.rs:11:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/sample.rs:51:9: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/sample.rs:58:19: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+xsv-0.13.0/src/cmd/sample.rs:69:9: wildcard match will miss any future added variants
+xsv-0.13.0/src/cmd/sample.rs:75:16: it is more concise to loop over containers instead of using explicit iteration methods
+xsv-0.13.0/src/cmd/sample.rs:91:42: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
+xsv-0.13.0/src/cmd/sample.rs:92:43: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
+xsv-0.13.0/src/cmd/search.rs:51:9: binding's name is too similar to existing binding
 xsv-0.13.0/src/cmd/search.rs:9:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/select.rs:60:9: binding's name is too similar to existing binding
 xsv-0.13.0/src/cmd/select.rs:8:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/slice.rs:57:9: binding's name is too similar to existing binding
 xsv-0.13.0/src/cmd/slice.rs:9:16: statics have by default a `'static` lifetime
 xsv-0.13.0/src/cmd/sort.rs:11:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/sort.rs:138:47: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+xsv-0.13.0/src/cmd/sort.rs:139:51: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+xsv-0.13.0/src/cmd/sort.rs:48:9: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/sort.rs:91:14: it is more concise to loop over containers instead of using explicit iteration methods
 xsv-0.13.0/src/cmd/split.rs:131:36: trait objects without an explicit `dyn` are deprecated
 xsv-0.13.0/src/cmd/split.rs:14:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/split.rs:61:9: binding's name is too similar to existing binding
 xsv-0.13.0/src/cmd/split.rs:94:5: this function's return value is unnecessarily wrapped by `Result`
+xsv-0.13.0/src/cmd/split.rs:96:14: this argument is passed by value, but not consumed in the function body
+xsv-0.13.0/src/cmd/split.rs:99:13: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
+xsv-0.13.0/src/cmd/stats.rs:110:36: redundant closure found
+xsv-0.13.0/src/cmd/stats.rs:127:14: this argument is passed by value, but not consumed in the function body
+xsv-0.13.0/src/cmd/stats.rs:138:43: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
+xsv-0.13.0/src/cmd/stats.rs:139:43: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
+xsv-0.13.0/src/cmd/stats.rs:162:25: it is more concise to loop over containers instead of using explicit iteration methods
 xsv-0.13.0/src/cmd/stats.rs:22:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/stats.rs:231:1: more than 3 bools in a struct
+xsv-0.13.0/src/cmd/stats.rs:262:35: calling `cmd::stats::TypedSum::default()` is more clear than this expression
+xsv-0.13.0/src/cmd/stats.rs:263:40: calling `cmd::stats::TypedMinMax::default()` is more clear than this expression
+xsv-0.13.0/src/cmd/stats.rs:264:39: calling `stats::OnlineStats::default()` is more clear than this expression
+xsv-0.13.0/src/cmd/stats.rs:265:58: calling `stats::Unsorted::default()` is more clear than this expression
+xsv-0.13.0/src/cmd/stats.rs:266:41: calling `stats::Unsorted::default()` is more clear than this expression
+xsv-0.13.0/src/cmd/stats.rs:268:18: calling `cmd::stats::FieldType::default()` is more clear than this expression
 xsv-0.13.0/src/cmd/stats.rs:269:13: redundant field names in struct initialization
 xsv-0.13.0/src/cmd/stats.rs:270:13: redundant field names in struct initialization
 xsv-0.13.0/src/cmd/stats.rs:271:13: redundant field names in struct initialization
@@ -143,33 +1649,86 @@ xsv-0.13.0/src/cmd/stats.rs:283:9: called `map(f)` on an `Option` value where `f
 xsv-0.13.0/src/cmd/stats.rs:284:9: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
 xsv-0.13.0/src/cmd/stats.rs:285:9: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
 xsv-0.13.0/src/cmd/stats.rs:290:21: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
+xsv-0.13.0/src/cmd/stats.rs:293:25: this `match` has identical arm bodies
 xsv-0.13.0/src/cmd/stats.rs:297:25: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
 xsv-0.13.0/src/cmd/stats.rs:301:21: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
 xsv-0.13.0/src/cmd/stats.rs:302:21: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
 xsv-0.13.0/src/cmd/stats.rs:308:18: methods called `to_*` usually take self by reference; consider choosing a less ambiguous name
+xsv-0.13.0/src/cmd/stats.rs:318:9: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+xsv-0.13.0/src/cmd/stats.rs:322:45: redundant closure found
+xsv-0.13.0/src/cmd/stats.rs:322:9: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+xsv-0.13.0/src/cmd/stats.rs:327:9: unnecessary boolean `not` operation
+xsv-0.13.0/src/cmd/stats.rs:330:13: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+xsv-0.13.0/src/cmd/stats.rs:338:45: redundant closure found
 xsv-0.13.0/src/cmd/stats.rs:402:16: redundant pattern matching, consider using `is_ok()`
 xsv-0.13.0/src/cmd/stats.rs:403:16: redundant pattern matching, consider using `is_ok()`
+xsv-0.13.0/src/cmd/stats.rs:407:18: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+xsv-0.13.0/src/cmd/stats.rs:411:16: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+xsv-0.13.0/src/cmd/stats.rs:427:56: this `match` has identical arm bodies
+xsv-0.13.0/src/cmd/stats.rs:429:56: this `match` has identical arm bodies
+xsv-0.13.0/src/cmd/stats.rs:430:60: this `match` has identical arm bodies
+xsv-0.13.0/src/cmd/stats.rs:430:60: this `match` has identical arm bodies
+xsv-0.13.0/src/cmd/stats.rs:454:5: you should put `TypedSum` between ticks in the documentation
+xsv-0.13.0/src/cmd/stats.rs:473:43: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+xsv-0.13.0/src/cmd/stats.rs:504:56: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+xsv-0.13.0/src/cmd/stats.rs:505:51: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+xsv-0.13.0/src/cmd/stats.rs:511:5: you should put `TypedMinMax` between ticks in the documentation
+xsv-0.13.0/src/cmd/stats.rs:536:35: casting `f64` to `i64` may truncate the value
+xsv-0.13.0/src/cmd/stats.rs:544:33: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+xsv-0.13.0/src/cmd/stats.rs:592:22: calling `stats::MinMax::default()` is more clear than this expression
+xsv-0.13.0/src/cmd/stats.rs:593:22: calling `stats::MinMax::default()` is more clear than this expression
+xsv-0.13.0/src/cmd/stats.rs:594:23: calling `stats::MinMax::default()` is more clear than this expression
+xsv-0.13.0/src/cmd/stats.rs:595:21: calling `stats::MinMax::default()` is more clear than this expression
+xsv-0.13.0/src/cmd/stats.rs:71:1: more than 3 bools in a struct
+xsv-0.13.0/src/cmd/stats.rs:86:9: binding's name is too similar to existing binding
 xsv-0.13.0/src/cmd/table.rs:10:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/table.rs:50:9: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/table.rs:54:9: binding's name is too similar to existing binding
 xsv-0.13.0/src/config.rs:113:43: use of `unwrap_or` followed by a function call
 xsv-0.13.0/src/config.rs:197:48: trait objects without an explicit `dyn` are deprecated
 xsv-0.13.0/src/config.rs:202:48: trait objects without an explicit `dyn` are deprecated
 xsv-0.13.0/src/config.rs:263:47: trait objects without an explicit `dyn` are deprecated
 xsv-0.13.0/src/config.rs:293:47: trait objects without an explicit `dyn` are deprecated
+xsv-0.13.0/src/config.rs:58:1: more than 3 bools in a struct
+xsv-0.13.0/src/config.rs:77:28: explicit deref method call
 xsv-0.13.0/src/config.rs:90:13: redundant field names in struct initialization
 xsv-0.13.0/src/index.rs:31:13: redundant field names in struct initialization
 xsv-0.13.0/src/main.rs:164:49: redundant clone
 xsv-0.13.0/src/main.rs:75:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/select.rs:13:1: item name starts with its containing module's name
 xsv-0.13.0/src/select.rs:154:5: this function's return value is unnecessarily wrapped by `Result`
+xsv-0.13.0/src/select.rs:250:33: binding's name is too similar to existing binding
+xsv-0.13.0/src/select.rs:250:43: binding's name is too similar to existing binding
+xsv-0.13.0/src/select.rs:255:39: an inclusive range would be more readable
 xsv-0.13.0/src/select.rs:280:20: length comparison to zero
 xsv-0.13.0/src/select.rs:29:13: redundant field names in struct initialization
+xsv-0.13.0/src/select.rs:360:62: this argument (8 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
 xsv-0.13.0/src/select.rs:360:9: this function's return value is unnecessarily wrapped by `Option`
 xsv-0.13.0/src/select.rs:375:9: used sort instead of sort_unstable to sort primitive type `usize`
+xsv-0.13.0/src/select.rs:379:18: it is more concise to loop over containers instead of using explicit iteration methods
 xsv-0.13.0/src/select.rs:416:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
 xsv-0.13.0/src/select.rs:419:9: this function's return value is unnecessarily wrapped by `Option`
+xsv-0.13.0/src/select.rs:420:27: consider using `Option<T>` instead of `Option<Option<T>>` or a custom enum if you need to distinguish all 3 cases
+xsv-0.13.0/src/select.rs:99:17: binding's name is too similar to existing binding
+xsv-0.13.0/src/util.rs:150:5: you should put bare URLs between `<`/`>` or make a proper Markdown link
 xsv-0.13.0/src/util.rs:190:48: trait objects without an explicit `dyn` are deprecated
 xsv-0.13.0/src/util.rs:37:33: you are using an explicit closure for copying elements
 xsv-0.13.0/src/util.rs:90:1: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+rayon-1.5.0/src/collections/binary_heap.rs:7:5: usage of wildcard import
+rayon-1.5.0/src/collections/binary_heap.rs:8:5: usage of wildcard import
+rayon-1.5.0/src/collections/btree_map.rs:7:5: usage of wildcard import
+rayon-1.5.0/src/collections/btree_map.rs:8:5: usage of wildcard import
+rayon-1.5.0/src/collections/btree_set.rs:7:5: usage of wildcard import
+rayon-1.5.0/src/collections/btree_set.rs:8:5: usage of wildcard import
+rayon-1.5.0/src/collections/hash_map.rs:10:5: usage of wildcard import
+rayon-1.5.0/src/collections/hash_map.rs:9:5: usage of wildcard import
+rayon-1.5.0/src/collections/hash_set.rs:10:5: usage of wildcard import
+rayon-1.5.0/src/collections/hash_set.rs:9:5: usage of wildcard import
+rayon-1.5.0/src/collections/linked_list.rs:7:5: usage of wildcard import
+rayon-1.5.0/src/collections/linked_list.rs:8:5: usage of wildcard import
 rayon-1.5.0/src/collections/mod.rs:59:32: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
+rayon-1.5.0/src/collections/vec_deque.rs:8:5: usage of wildcard import
+rayon-1.5.0/src/collections/vec_deque.rs:9:5: usage of wildcard import
 rayon-1.5.0/src/compile_fail/cannot_collect_filtermap_data.rs:2:1: needless `fn main` in doctest
 rayon-1.5.0/src/compile_fail/cannot_zip_filtered_data.rs:2:1: needless `fn main` in doctest
 rayon-1.5.0/src/compile_fail/cell_par_iter.rs:2:1: needless `fn main` in doctest
@@ -177,13 +1736,339 @@ rayon-1.5.0/src/compile_fail/no_send_par_iter.rs:25:1: needless `fn main` in doc
 rayon-1.5.0/src/compile_fail/no_send_par_iter.rs:46:1: needless `fn main` in doctest
 rayon-1.5.0/src/compile_fail/no_send_par_iter.rs:4:1: needless `fn main` in doctest
 rayon-1.5.0/src/compile_fail/rc_par_iter.rs:2:1: needless `fn main` in doctest
+rayon-1.5.0/src/iter/chain.rs:103:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/chain.rs:122:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/chain.rs:128:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/chain.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/chain.rs:221:36: you should put `ExactSizeIterator` between ticks in the documentation
+rayon-1.5.0/src/iter/chain.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/chain.rs:51:38: use Option::map_or_else instead of an if let/else
+rayon-1.5.0/src/iter/chain.rs:58:14: `a` is being shadowed
+rayon-1.5.0/src/iter/chain.rs:58:17: `b` is being shadowed
+rayon-1.5.0/src/iter/chain.rs:78:14: `a` is being shadowed
+rayon-1.5.0/src/iter/chain.rs:78:17: `b` is being shadowed
+rayon-1.5.0/src/iter/chain.rs:97:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/chunks.rs:3:5: usage of wildcard import
+rayon-1.5.0/src/iter/chunks.rs:4:5: usage of wildcard import
+rayon-1.5.0/src/iter/chunks.rs:77:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/chunks.rs:83:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/cloned.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/cloned.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/cloned.rs:71:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/cloned.rs:75:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/collect/consumer.rs:141:5: you should put `CollectReducer` between ticks in the documentation
+rayon-1.5.0/src/iter/collect/consumer.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/collect/consumer.rs:28:5: you should put `CollectResult` between ticks in the documentation
+rayon-1.5.0/src/iter/collect/consumer.rs:36:37: generally you want to avoid `&mut &mut _` if possible
+rayon-1.5.0/src/iter/collect/consumer.rs:36:37: generally you want to avoid `&mut &mut _` if possible
+rayon-1.5.0/src/iter/collect/mod.rs:154:9: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+rayon-1.5.0/src/iter/copied.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/copied.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/copied.rs:71:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/copied.rs:75:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/empty.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/empty.rs:24:1: this function could have a `#[must_use]` attribute
+rayon-1.5.0/src/iter/empty.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/enumerate.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/enumerate.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/enumerate.rs:64:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/enumerate.rs:68:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/extend.rs:143:63: I see you're using a LinkedList! Perhaps you meant some other data structure?
+rayon-1.5.0/src/iter/extend.rs:182:57: I see you're using a LinkedList! Perhaps you meant some other data structure?
+rayon-1.5.0/src/iter/extend.rs:218:32: I see you're using a LinkedList! Perhaps you meant some other data structure?
+rayon-1.5.0/src/iter/extend.rs:218:59: I see you're using a LinkedList! Perhaps you meant some other data structure?
+rayon-1.5.0/src/iter/extend.rs:25:42: I see you're using a LinkedList! Perhaps you meant some other data structure?
+rayon-1.5.0/src/iter/extend.rs:287:62: I see you're using a LinkedList! Perhaps you meant some other data structure?
+rayon-1.5.0/src/iter/extend.rs:322:56: I see you're using a LinkedList! Perhaps you meant some other data structure?
+rayon-1.5.0/src/iter/extend.rs:41:27: I see you're using a LinkedList! Perhaps you meant some other data structure?
+rayon-1.5.0/src/iter/extend.rs:47:30: I see you're using a LinkedList! Perhaps you meant some other data structure?
+rayon-1.5.0/src/iter/extend.rs:47:56: I see you're using a LinkedList! Perhaps you meant some other data structure?
+rayon-1.5.0/src/iter/extend.rs:47:74: I see you're using a LinkedList! Perhaps you meant some other data structure?
+rayon-1.5.0/src/iter/extend.rs:53:29: I see you're using a LinkedList! Perhaps you meant some other data structure?
+rayon-1.5.0/src/iter/extend.rs:57:36: I see you're using a LinkedList! Perhaps you meant some other data structure?
+rayon-1.5.0/src/iter/extend.rs:59:61: I see you're using a LinkedList! Perhaps you meant some other data structure?
+rayon-1.5.0/src/iter/filter.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/filter.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/filter_map.rs:123:9: use Option::map_or instead of an if let/else
+rayon-1.5.0/src/iter/filter_map.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/filter_map.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/find.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/find.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/find_first_last/mod.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/find_first_last/mod.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/find_first_last/mod.rs:32:67: you should put `MatchPosition` between ticks in the documentation
+rayon-1.5.0/src/iter/flat_map.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/flat_map.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/flat_map_iter.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/flat_map_iter.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/flatten.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/flatten.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/flatten_iter.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/flatten_iter.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/fold.rs:158:13: binding's name is too similar to existing binding
+rayon-1.5.0/src/iter/fold.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/fold.rs:204:1: item name starts with its containing module's name
+rayon-1.5.0/src/iter/fold.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/for_each.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/for_each.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/inspect.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/inspect.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/inspect.rs:83:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/inspect.rs:88:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/interleave.rs:111:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/interleave.rs:119:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/interleave.rs:195:30: you should put `self.i_len` between ticks in the documentation
+rayon-1.5.0/src/iter/interleave.rs:195:43: you should put `self.j_len` between ticks in the documentation
+rayon-1.5.0/src/iter/interleave.rs:199:23: you should put `self.i_len` between ticks in the documentation
+rayon-1.5.0/src/iter/interleave.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/interleave.rs:200:23: you should put `self.j_len` between ticks in the documentation
+rayon-1.5.0/src/iter/interleave.rs:249:41: you should put `DoubleEndedIterator` between ticks in the documentation
+rayon-1.5.0/src/iter/interleave.rs:250:5: you should put `ExactSizeIterator` between ticks in the documentation
+rayon-1.5.0/src/iter/interleave.rs:263:33: you should put `InterleaveSeq` between ticks in the documentation
+rayon-1.5.0/src/iter/interleave.rs:280:17: wildcard match will miss any future added variants
+rayon-1.5.0/src/iter/interleave.rs:285:17: wildcard match will miss any future added variants
+rayon-1.5.0/src/iter/interleave.rs:2:5: usage of wildcard import
 rayon-1.5.0/src/iter/interleave.rs:313:9: `if` chain can be rewritten with `match`
+rayon-1.5.0/src/iter/interleave.rs:82:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/interleave.rs:90:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/interleave_shortest.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/intersperse.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/intersperse.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/intersperse.rs:90:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/intersperse.rs:96:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/len.rs:12:1: item name ends with its containing module's name
+rayon-1.5.0/src/iter/len.rs:146:1: item name ends with its containing module's name
+rayon-1.5.0/src/iter/len.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/len.rs:200:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/len.rs:205:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/len.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/len.rs:66:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/len.rs:71:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/map.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/map.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/map.rs:84:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/map.rs:89:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/map_with.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/map_with.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/map_with.rs:419:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/map_with.rs:425:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/map_with.rs:90:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/map_with.rs:96:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/mod.rs:1874:24: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
 rayon-1.5.0/src/iter/mod.rs:2171:1: trait `IndexedParallelIterator` has a `len` method but no (possibly inherited) `is_empty` method
+rayon-1.5.0/src/iter/mod.rs:2371:26: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+rayon-1.5.0/src/iter/mod.rs:2411:26: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+rayon-1.5.0/src/iter/mod.rs:82:5: usage of wildcard import
+rayon-1.5.0/src/iter/multizip.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/multizip.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/noop.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/once.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/once.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/panic_fuse.rs:102:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/panic_fuse.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/panic_fuse.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/panic_fuse.rs:98:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/par_bridge.rs:136:28: redundant else block
+rayon-1.5.0/src/iter/par_bridge.rs:163:28: redundant else block
+rayon-1.5.0/src/iter/plumbing/mod.rs:216:58: you should put `find_first` between ticks in the documentation
+rayon-1.5.0/src/iter/plumbing/mod.rs:359:5: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/plumbing/mod.rs:364:5: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/plumbing/mod.rs:399:5: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/plumbing/mod.rs:53:19: you should put `DoubleEndedIterator` between ticks in the documentation
+rayon-1.5.0/src/iter/plumbing/mod.rs:53:43: you should put `ExactSizeIterator` between ticks in the documentation
+rayon-1.5.0/src/iter/plumbing/mod.rs:54:31: you should put `IntoIterator` between ticks in the documentation
+rayon-1.5.0/src/iter/plumbing/mod.rs:55:5: you should put `IntoIterator` between ticks in the documentation
+rayon-1.5.0/src/iter/positions.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/positions.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/product.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/reduce.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/repeat.rs:103:1: item name starts with its containing module's name
+rayon-1.5.0/src/iter/repeat.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/repeat.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/rev.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/rev.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/rev.rs:63:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/rev.rs:68:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/skip.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/skip.rs:3:5: usage of wildcard import
+rayon-1.5.0/src/iter/skip.rs:68:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/skip.rs:73:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/splitter.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/splitter.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/step_by.rs:4:5: usage of wildcard import
+rayon-1.5.0/src/iter/step_by.rs:5:5: usage of wildcard import
+rayon-1.5.0/src/iter/step_by.rs:73:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/step_by.rs:79:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/sum.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/take.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/take.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/take.rs:67:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/take.rs:72:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/try_fold.rs:190:1: item name starts with its containing module's name
+rayon-1.5.0/src/iter/try_fold.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/try_fold.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/try_reduce.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/try_reduce_with.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/unzip.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/unzip.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/update.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/update.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/update.rs:82:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/update.rs:87:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/while_some.rs:130:22: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+rayon-1.5.0/src/iter/while_some.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/while_some.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/zip.rs:102:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/zip.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/zip.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/zip.rs:74:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/zip.rs:79:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/zip.rs:97:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/zip_eq.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/zip_eq.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/option.rs:8:5: usage of wildcard import
+rayon-1.5.0/src/option.rs:9:5: usage of wildcard import
+rayon-1.5.0/src/par_either.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/par_either.rs:3:5: usage of wildcard import
+rayon-1.5.0/src/private.rs:9:1: item name starts with its containing module's name
+rayon-1.5.0/src/range.rs:19:5: usage of wildcard import
+rayon-1.5.0/src/range.rs:20:5: usage of wildcard import
+rayon-1.5.0/src/range_inclusive.rs:194:9: an inclusive range would be more readable
+rayon-1.5.0/src/range_inclusive.rs:194:9: an inclusive range would be more readable
+rayon-1.5.0/src/range_inclusive.rs:19:5: usage of wildcard import
+rayon-1.5.0/src/range_inclusive.rs:209:9: an inclusive range would be more readable
+rayon-1.5.0/src/range_inclusive.rs:209:9: an inclusive range would be more readable
+rayon-1.5.0/src/range_inclusive.rs:20:5: usage of wildcard import
+rayon-1.5.0/src/range_inclusive.rs:231:9: an inclusive range would be more readable
+rayon-1.5.0/src/range_inclusive.rs:231:9: an inclusive range would be more readable
+rayon-1.5.0/src/result.rs:8:5: usage of wildcard import
+rayon-1.5.0/src/result.rs:9:5: usage of wildcard import
+rayon-1.5.0/src/slice/mergesort.rs:102:5: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/slice/mergesort.rs:109:5: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/slice/mergesort.rs:114:5: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/slice/mergesort.rs:211:5: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/slice/mergesort.rs:217:5: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/slice/mergesort.rs:251:5: you should put `TimSort` between ticks in the documentation
+rayon-1.5.0/src/slice/mergesort.rs:252:5: you should put bare URLs between `<`/`>` or make a proper Markdown link
+rayon-1.5.0/src/slice/mergesort.rs:286:59: you should put `TimSort` between ticks in the documentation
+rayon-1.5.0/src/slice/mergesort.rs:333:24: redundant else block
+rayon-1.5.0/src/slice/mergesort.rs:513:5: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/slice/mergesort.rs:521:5: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/slice/mergesort.rs:7:5: usage of wildcard import
+rayon-1.5.0/src/slice/mergesort.rs:98:5: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/slice/mod.rs:15:5: usage of wildcard import
+rayon-1.5.0/src/slice/mod.rs:16:5: usage of wildcard import
+rayon-1.5.0/src/slice/mod.rs:17:5: usage of wildcard import
+rayon-1.5.0/src/slice/mod.rs:25:1: item name ends with its containing module's name
+rayon-1.5.0/src/slice/mod.rs:657:5: this method could have a `#[must_use]` attribute
+rayon-1.5.0/src/slice/mod.rs:971:5: this method could have a `#[must_use]` attribute
+rayon-1.5.0/src/slice/quicksort.rs:230:36: you should put `BlockQuicksort` between ticks in the documentation
+rayon-1.5.0/src/slice/quicksort.rs:233:1: this function has too many lines (117/100)
+rayon-1.5.0/src/slice/quicksort.rs:258:26: integer type suffix should be separated by an underscore
+rayon-1.5.0/src/slice/quicksort.rs:265:26: integer type suffix should be separated by an underscore
+rayon-1.5.0/src/slice/quicksort.rs:268:5: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/slice/quicksort.rs:308:30: casting `usize` to `u8` may truncate the value
+rayon-1.5.0/src/slice/quicksort.rs:325:30: casting `usize` to `u8` may truncate the value
+rayon-1.5.0/src/slice/quicksort.rs:393:36: casting `u8` to `isize` may wrap around the value on targets with 32-bit wide pointers
+rayon-1.5.0/src/slice/quicksort.rs:405:40: casting `u8` to `isize` may wrap around the value on targets with 32-bit wide pointers
+rayon-1.5.0/src/slice/quicksort.rs:430:14: `pivot` is being shadowed
+rayon-1.5.0/src/slice/quicksort.rs:439:13: `pivot` is being shadowed
+rayon-1.5.0/src/slice/quicksort.rs:482:10: `pivot` is being shadowed
+rayon-1.5.0/src/slice/quicksort.rs:491:9: `pivot` is being shadowed
+rayon-1.5.0/src/slice/quicksort.rs:534:26: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+rayon-1.5.0/src/slice/quicksort.rs:545:17: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
 rayon-1.5.0/src/slice/quicksort.rs:588:17: the operation is ineffective. Consider reducing it to `len / 4`
+rayon-1.5.0/src/slice/quicksort.rs:716:14: `pivot` is being shadowed
+rayon-1.5.0/src/split_producer.rs:56:16: use Option::map_or_else instead of an if let/else
+rayon-1.5.0/src/split_producer.rs:92:9: use Option::map_or instead of an if let/else
+rayon-1.5.0/src/str.rs:16:5: usage of wildcard import
+rayon-1.5.0/src/str.rs:17:5: usage of wildcard import
+rayon-1.5.0/src/str.rs:18:5: usage of wildcard import
+rayon-1.5.0/src/str.rs:25:5: casting `u8` to `i8` may wrap around the value
 rayon-1.5.0/src/str.rs:715:9: stripping a suffix manually
+rayon-1.5.0/src/string.rs:5:5: usage of wildcard import
 rayon-1.5.0/src/vec.rs:137:12: length comparison to zero
+rayon-1.5.0/src/vec.rs:8:5: usage of wildcard import
+rayon-1.5.0/src/vec.rs:9:5: usage of wildcard import
+rand-0.7.3/src/distributions/bernoulli.rs:103:20: casting `f64` to `u64` may lose the sign of the value
+rand-0.7.3/src/distributions/bernoulli.rs:103:20: casting `f64` to `u64` may truncate the value
+rand-0.7.3/src/distributions/bernoulli.rs:116:5: docs for function returning `Result` missing `# Errors` section
+rand-0.7.3/src/distributions/bernoulli.rs:123:21: casting `f64` to `u64` may lose the sign of the value
+rand-0.7.3/src/distributions/bernoulli.rs:123:21: casting `f64` to `u64` may truncate the value
+rand-0.7.3/src/distributions/bernoulli.rs:63:26: casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/bernoulli.rs:63:27: integer type suffix should be separated by an underscore
+rand-0.7.3/src/distributions/bernoulli.rs:67:1: item name starts with its containing module's name
+rand-0.7.3/src/distributions/bernoulli.rs:95:5: docs for function returning `Result` missing `# Errors` section
 rand-0.7.3/src/distributions/bernoulli.rs:96:13: manual `Range::contains` implementation
+rand-0.7.3/src/distributions/binomial.rs:107:23: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/binomial.rs:112:44: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/binomial.rs:116:13: adding items after statements is confusing, since items exist from the start of the scope
+rand-0.7.3/src/distributions/binomial.rs:150:28: redundant else block
+rand-0.7.3/src/distributions/binomial.rs:153:24: unnecessary boolean `not` operation
+rand-0.7.3/src/distributions/binomial.rs:158:28: redundant else block
+rand-0.7.3/src/distributions/binomial.rs:164:33: casting `i64` to `u64` may lose the sign of the value
+rand-0.7.3/src/distributions/binomial.rs:166:28: redundant else block
+rand-0.7.3/src/distributions/binomial.rs:175:47: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/binomial.rs:185:38: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/binomial.rs:194:38: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/binomial.rs:202:28: redundant else block
+rand-0.7.3/src/distributions/binomial.rs:209:25: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/binomial.rs:221:26: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/binomial.rs:222:26: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/binomial.rs:223:25: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/binomial.rs:224:25: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/binomial.rs:226:17: adding items after statements is confusing, since items exist from the start of the scope
+rand-0.7.3/src/distributions/binomial.rs:233:32: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/binomial.rs:234:27: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/binomial.rs:251:22: casting `i64` to `u64` may lose the sign of the value
+rand-0.7.3/src/distributions/binomial.rs:255:9: unnecessary `!=` operation
+rand-0.7.3/src/distributions/binomial.rs:35:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/distributions/binomial.rs:45:17: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/binomial.rs:46:5: casting `f64` to `i64` may truncate the value
+rand-0.7.3/src/distributions/binomial.rs:50:5: this function has too many lines (143/100)
+rand-0.7.3/src/distributions/binomial.rs:76:9: adding items after statements is confusing, since items exist from the start of the scope
+rand-0.7.3/src/distributions/binomial.rs:78:12: casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/binomial.rs:81:21: casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/binomial.rs:82:32: casting `u64` to `i32` may truncate the value
+rand-0.7.3/src/distributions/binomial.rs:88:26: casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/binomial.rs:99:21: casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/cauchy.rs:33:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/distributions/dirichlet.rs:52:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/distributions/dirichlet.rs:64:32: float type suffix should be separated by an underscore
+rand-0.7.3/src/distributions/dirichlet.rs:65:23: float type suffix should be separated by an underscore
+rand-0.7.3/src/distributions/exponential.rs:76:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/distributions/float.rs:73:1: item name ends with its containing module's name
+rand-0.7.3/src/distributions/gamma.rs:13:5: usage of wildcard import for enum variants
+rand-0.7.3/src/distributions/gamma.rs:14:5: usage of wildcard import for enum variants
+rand-0.7.3/src/distributions/gamma.rs:189:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/distributions/gamma.rs:230:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/distributions/gamma.rs:259:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/distributions/gamma.rs:287:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/distributions/gamma.rs:90:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/distributions/integer.rs:23:9: casting `u32` to `u8` may truncate the value
+rand-0.7.3/src/distributions/integer.rs:30:9: casting `u32` to `u16` may truncate the value
+rand-0.7.3/src/distributions/integer.rs:69:9: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
+rand-0.7.3/src/distributions/mod.rs:263:5: you have declared `#[inline(always)]` on `next`. This is usually a bad idea
+rand-0.7.3/src/distributions/normal.rs:100:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/distributions/normal.rs:119:1: item name ends with its containing module's name
+rand-0.7.3/src/distributions/normal.rs:131:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/distributions/normal.rs:31:1: item name ends with its containing module's name
+rand-0.7.3/src/distributions/normal.rs:47:25: float type suffix should be separated by an underscore
+rand-0.7.3/src/distributions/normal.rs:48:25: float type suffix should be separated by an underscore
+rand-0.7.3/src/distributions/other.rs:89:9: casting `u32` to `i32` may wrap around the value
+rand-0.7.3/src/distributions/pareto.rs:32:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/distributions/poisson.rs:35:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/distributions/poisson.rs:87:30: casting `f64` to `u64` may lose the sign of the value
+rand-0.7.3/src/distributions/poisson.rs:87:30: casting `f64` to `u64` may truncate the value
+rand-0.7.3/src/distributions/triangular.rs:32:5: this method could have a `#[must_use]` attribute
 rand-0.7.3/src/distributions/uniform.rs:146:4: needless `fn main` in doctest
+rand-0.7.3/src/distributions/uniform.rs:199:1: item name ends with its containing module's name
+rand-0.7.3/src/distributions/uniform.rs:214:1: item name starts with its containing module's name
+rand-0.7.3/src/distributions/uniform.rs:283:14: you should put `SampleUniform` between ticks in the documentation
+rand-0.7.3/src/distributions/uniform.rs:283:46: you should put `SampleUniform` between ticks in the documentation
+rand-0.7.3/src/distributions/uniform.rs:296:5: you have declared `#[inline(always)]` on `borrow`. This is usually a bad idea
+rand-0.7.3/src/distributions/uniform.rs:304:5: you have declared `#[inline(always)]` on `borrow`. This is usually a bad idea
+rand-0.7.3/src/distributions/uniform.rs:350:1: item name starts with its containing module's name
 rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
 rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
 rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
@@ -196,90 +2081,799 @@ rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct
 rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
 rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
 rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
+rand-0.7.3/src/distributions/uniform.rs:441:31: because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false
+rand-0.7.3/src/distributions/uniform.rs:441:31: because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false
+rand-0.7.3/src/distributions/uniform.rs:441:31: because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false
+rand-0.7.3/src/distributions/uniform.rs:441:31: because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false
+rand-0.7.3/src/distributions/uniform.rs:441:31: because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false
+rand-0.7.3/src/distributions/uniform.rs:441:31: because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false
+rand-0.7.3/src/distributions/uniform.rs:441:31: because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false
+rand-0.7.3/src/distributions/uniform.rs:441:31: because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false
+rand-0.7.3/src/distributions/uniform.rs:56:10: you should put `SampleBorrow` between ticks in the documentation
+rand-0.7.3/src/distributions/uniform.rs:647:1: item name starts with its containing module's name
+rand-0.7.3/src/distributions/uniform.rs:840:1: item name starts with its containing module's name
+rand-0.7.3/src/distributions/uniform.rs:913:13: use Option::map_or_else instead of an if let/else
+rand-0.7.3/src/distributions/uniform.rs:943:54: casting `u64` to `u32` may truncate the value
+rand-0.7.3/src/distributions/unit_circle.rs:30:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/distributions/unit_sphere.rs:24:1: item name starts with its containing module's name
+rand-0.7.3/src/distributions/unit_sphere.rs:29:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/distributions/utils.rs:254:5: you have declared `#[inline(always)]` on `lanes`. This is usually a bad idea
+rand-0.7.3/src/distributions/utils.rs:258:5: you have declared `#[inline(always)]` on `splat`. This is usually a bad idea
+rand-0.7.3/src/distributions/utils.rs:262:5: you have declared `#[inline(always)]` on `extract`. This is usually a bad idea
+rand-0.7.3/src/distributions/utils.rs:267:5: you have declared `#[inline(always)]` on `replace`. This is usually a bad idea
+rand-0.7.3/src/distributions/utils.rs:281:5: you have declared `#[inline(always)]` on `any`. This is usually a bad idea
+rand-0.7.3/src/distributions/utils.rs:286:5: you have declared `#[inline(always)]` on `all`. This is usually a bad idea
+rand-0.7.3/src/distributions/utils.rs:291:5: you have declared `#[inline(always)]` on `none`. This is usually a bad idea
+rand-0.7.3/src/distributions/utils.rs:488:17: you should put `x_i` between ticks in the documentation
+rand-0.7.3/src/distributions/utils.rs:489:50: you should put `x_i` between ticks in the documentation
+rand-0.7.3/src/distributions/utils.rs:489:63: you should put `f(x_i` between ticks in the documentation
+rand-0.7.3/src/distributions/utils.rs:490:40: you should put `f(x_i` between ticks in the documentation
+rand-0.7.3/src/distributions/utils.rs:490:49: you should put `f(x_{i+1` between ticks in the documentation
+rand-0.7.3/src/distributions/utils.rs:518:17: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
+rand-0.7.3/src/distributions/weibull.rs:29:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/distributions/weighted/alias_method.rs:113:21: it is more concise to loop over references to containers instead of using explicit iteration methods
+rand-0.7.3/src/distributions/weighted/alias_method.rs:125:9: adding items after statements is confusing, since items exist from the start of the scope
+rand-0.7.3/src/distributions/weighted/alias_method.rs:131:9: adding items after statements is confusing, since items exist from the start of the scope
+rand-0.7.3/src/distributions/weighted/alias_method.rs:180:36: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+rand-0.7.3/src/distributions/weighted/alias_method.rs:182:34: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
 rand-0.7.3/src/distributions/weighted/alias_method.rs:259:28: using `clone` on type `distributions::uniform::Uniform<u32>` which implements the `Copy` trait
 rand-0.7.3/src/distributions/weighted/alias_method.rs:296:9: you are using an explicit closure for copying elements
 rand-0.7.3/src/distributions/weighted/alias_method.rs:321:9: you are using an explicit closure for copying elements
+rand-0.7.3/src/distributions/weighted/alias_method.rs:78:5: docs for function returning `Result` missing `# Errors` section
+rand-0.7.3/src/distributions/weighted/alias_method.rs:78:5: this function has too many lines (106/100)
+rand-0.7.3/src/distributions/weighted/alias_method.rs:85:17: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+rand-0.7.3/src/distributions/weighted/alias_method.rs:87:31: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
+rand-0.7.3/src/distributions/weighted/mod.rs:100:5: docs for function returning `Result` missing `# Errors` section
+rand-0.7.3/src/distributions/weighted/mod.rs:144:5: docs for function returning `Result` missing `# Errors` section
 rand-0.7.3/src/distributions/weighted/mod.rs:169:16: unnecessary `>= y + 1` or `x - 1 >=`
+rand-0.7.3/src/distributions/weighted/mod.rs:386:1: item name starts with its containing module's name
+rand-0.7.3/src/distributions/weighted/mod.rs:85:1: item name starts with its containing module's name
+rand-0.7.3/src/lib.rs:333:5: docs for function returning `Result` missing `# Errors` section
+rand-0.7.3/src/lib.rs:552:1: this function could have a `#[must_use]` attribute
+rand-0.7.3/src/rngs/adapter/read.rs:47:1: item name starts with its containing module's name
+rand-0.7.3/src/rngs/adapter/read.rs:89:1: item name starts with its containing module's name
+rand-0.7.3/src/rngs/adapter/reseeding.rs:100:5: docs for function returning `Result` missing `# Errors` section
+rand-0.7.3/src/rngs/adapter/reseeding.rs:112:5: you have declared `#[inline(always)]` on `next_u32`. This is usually a bad idea
+rand-0.7.3/src/rngs/adapter/reseeding.rs:117:5: you have declared `#[inline(always)]` on `next_u64`. This is usually a bad idea
+rand-0.7.3/src/rngs/adapter/reseeding.rs:198:13: casting `u64` to `i64` may wrap around the value
+rand-0.7.3/src/rngs/adapter/reseeding.rs:231:9: casting `usize` to `isize` may wrap around the value
+rand-0.7.3/src/rngs/adapter/reseeding.rs:27:28: you should put `ChaCha` between ticks in the documentation
+rand-0.7.3/src/rngs/adapter/reseeding.rs:79:1: item name starts with its containing module's name
+rand-0.7.3/src/rngs/entropy.rs:24:1: item name starts with its containing module's name
+rand-0.7.3/src/rngs/entropy.rs:34:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/rngs/mock.rs:36:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/rngs/mock.rs:47:9: casting `u64` to `u32` may truncate the value
+rand-0.7.3/src/rngs/mod.rs:61:74: you should put `ChaCha20` between ticks in the documentation
+rand-0.7.3/src/rngs/std.rs:25:39: you should put `ChaCha` between ticks in the documentation
+rand-0.7.3/src/rngs/std.rs:32:10: you should put `rand_chacha` between ticks in the documentation
+rand-0.7.3/src/rngs/std.rs:36:1: item name starts with its containing module's name
+rand-0.7.3/src/rngs/std.rs:39:5: you have declared `#[inline(always)]` on `next_u32`. This is usually a bad idea
+rand-0.7.3/src/rngs/std.rs:44:5: you have declared `#[inline(always)]` on `next_u64`. This is usually a bad idea
+rand-0.7.3/src/rngs/std.rs:49:5: you have declared `#[inline(always)]` on `fill_bytes`. This is usually a bad idea
+rand-0.7.3/src/rngs/std.rs:54:5: you have declared `#[inline(always)]` on `try_fill_bytes`. This is usually a bad idea
+rand-0.7.3/src/rngs/std.rs:63:5: you have declared `#[inline(always)]` on `from_seed`. This is usually a bad idea
+rand-0.7.3/src/rngs/std.rs:68:5: you have declared `#[inline(always)]` on `from_rng`. This is usually a bad idea
+rand-0.7.3/src/rngs/thread.rs:57:1: item name starts with its containing module's name
+rand-0.7.3/src/rngs/thread.rs:80:1: item name starts with its containing module's name
+rand-0.7.3/src/rngs/thread.rs:80:1: this function could have a `#[must_use]` attribute
+rand-0.7.3/src/rngs/thread.rs:81:35: redundant closure found
+rand-0.7.3/src/rngs/thread.rs:93:5: you have declared `#[inline(always)]` on `next_u32`. This is usually a bad idea
+rand-0.7.3/src/rngs/thread.rs:98:5: you have declared `#[inline(always)]` on `next_u64`. This is usually a bad idea
+rand-0.7.3/src/seq/index.rs:127:1: item name starts with its containing module's name
+rand-0.7.3/src/seq/index.rs:139:13: usage of wildcard import for enum variants
+rand-0.7.3/src/seq/index.rs:159:1: item name starts with its containing module's name
+rand-0.7.3/src/seq/index.rs:171:13: usage of wildcard import for enum variants
+rand-0.7.3/src/seq/index.rs:180:13: usage of wildcard import for enum variants
+rand-0.7.3/src/seq/index.rs:223:18: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+rand-0.7.3/src/seq/index.rs:224:18: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+rand-0.7.3/src/seq/index.rs:233:25: casting `u32` to `f32` causes a loss of precision (`u32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)
+rand-0.7.3/src/seq/index.rs:236:27: casting `u32` to `f32` causes a loss of precision (`u32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)
+rand-0.7.3/src/seq/index.rs:244:12: casting `u32` to `f32` causes a loss of precision (`u32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)
+rand-0.7.3/src/seq/index.rs:244:37: casting `u32` to `f32` causes a loss of precision (`u32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)
+rand-0.7.3/src/seq/index.rs:29:1: item name starts with its containing module's name
+rand-0.7.3/src/seq/index.rs:39:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/seq/index.rs:48:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/seq/index.rs:60:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/seq/index.rs:69:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/seq/index.rs:78:5: this method could have a `#[must_use]` attribute
 rand-0.7.3/src/seq/index.rs:87:5: method `into_iter` can be confused for the standard trait method `std::iter::IntoIterator::into_iter`
+rand-0.7.3/src/seq/index.rs:87:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/seq/index.rs:97:13: usage of wildcard import for enum variants
+rand-0.7.3/src/seq/mod.rs:141:5: docs for function returning `Result` missing `# Errors` section
+rand-0.7.3/src/seq/mod.rs:168:5: docs for function returning `Result` missing `# Errors` section
 rand-0.7.3/src/seq/mod.rs:229:4: needless `fn main` in doctest
+rand-0.7.3/src/seq/mod.rs:292:29: casting `usize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`usize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/seq/mod.rs:410:23: calling `std::marker::PhantomData::default()` is more clear than this expression
 rand-0.7.3/src/seq/mod.rs:45:4: needless `fn main` in doctest
+rand-0.7.3/src/seq/mod.rs:527:26: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
 syn-1.0.54/src/lit.rs:1397:40: redundant else block
 syn-1.0.54/src/lit.rs:1405:28: redundant else block
 syn-1.0.54/src/lit.rs:1485:32: redundant else block
+libc-0.2.81/build.rs:114:19: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
 libc-0.2.81/build.rs:124:5: this block may be rewritten with the `?` operator
 libc-0.2.81/build.rs:133:5: this block may be rewritten with the `?` operator
+libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
+libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
+libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
+libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
+libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
+libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
+libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
+libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
+libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
+libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
+libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
+libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
+libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
+libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
+libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
+libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
+libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
+libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
+libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
+libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
 libc-0.2.81/src/macros.rs:243:17: unsafe function's docs miss `# Safety` section
 libc-0.2.81/src/macros.rs:243:17: unsafe function's docs miss `# Safety` section
 libc-0.2.81/src/macros.rs:243:17: unsafe function's docs miss `# Safety` section
+libc-0.2.81/src/macros.rs:259:17: this function could have a `#[must_use]` attribute
+libc-0.2.81/src/macros.rs:259:17: this function could have a `#[must_use]` attribute
+libc-0.2.81/src/macros.rs:259:17: this function could have a `#[must_use]` attribute
+libc-0.2.81/src/macros.rs:259:17: this function could have a `#[must_use]` attribute
+libc-0.2.81/src/macros.rs:259:17: this function could have a `#[must_use]` attribute
+libc-0.2.81/src/macros.rs:259:17: this function could have a `#[must_use]` attribute
+libc-0.2.81/src/macros.rs:259:17: this function could have a `#[must_use]` attribute
+libc-0.2.81/src/macros.rs:259:17: this function could have a `#[must_use]` attribute
+libc-0.2.81/src/macros.rs:259:17: this function could have a `#[must_use]` attribute
+libc-0.2.81/src/macros.rs:259:17: this function could have a `#[must_use]` attribute
+libc-0.2.81/src/macros.rs:259:17: this function could have a `#[must_use]` attribute
+libc-0.2.81/src/macros.rs:259:17: this function could have a `#[must_use]` attribute
+libc-0.2.81/src/macros.rs:259:17: this function could have a `#[must_use]` attribute
+libc-0.2.81/src/macros.rs:259:17: this function could have a `#[must_use]` attribute
+libc-0.2.81/src/macros.rs:259:17: this function could have a `#[must_use]` attribute
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:428:29: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:429:30: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:431:30: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:432:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:433:29: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:434:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:595:33: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:596:33: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:597:35: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:622:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:673:34: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:696:33: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:697:35: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:698:33: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:699:35: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:712:34: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:721:35: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:722:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:723:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:751:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:752:30: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:753:30: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:754:30: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:755:29: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:756:29: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:757:29: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:758:29: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:759:29: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:760:29: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:768:30: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:769:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:771:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:772:29: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:773:29: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:774:29: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:775:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:776:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:777:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:778:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:779:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:780:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:781:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:782:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:783:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:784:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:785:33: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:786:33: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:787:30: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:788:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:789:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:790:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:791:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:792:33: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:794:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:795:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:796:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:797:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:798:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:799:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:800:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:801:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:803:27: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:804:28: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:805:28: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:806:29: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:807:29: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:808:29: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:809:29: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:810:29: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:811:29: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:812:30: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:813:30: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:814:30: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:815:30: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:816:30: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:817:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:818:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:821:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:822:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:823:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:824:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:825:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:826:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:827:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:828:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:829:33: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:830:33: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:831:33: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:832:33: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:833:33: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:834:33: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:835:33: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:836:33: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:841:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:842:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:843:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:844:33: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:1120:38: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:178:34: integer type suffix should be separated by an underscore
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:291:5: this method could have a `#[must_use]` attribute
 libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:291:5: unsafe function's docs miss `# Safety` section
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:302:5: this method could have a `#[must_use]` attribute
 libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:302:5: unsafe function's docs miss `# Safety` section
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:355:13: this method could have a `#[must_use]` attribute
 libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:355:13: unsafe function's docs miss `# Safety` section
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:359:13: this method could have a `#[must_use]` attribute
 libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:359:13: unsafe function's docs miss `# Safety` section
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:363:13: this method could have a `#[must_use]` attribute
 libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:363:13: unsafe function's docs miss `# Safety` section
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:367:13: this method could have a `#[must_use]` attribute
 libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:367:13: unsafe function's docs miss `# Safety` section
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:371:13: this method could have a `#[must_use]` attribute
 libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:371:13: unsafe function's docs miss `# Safety` section
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:534:36: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:645:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:727:40: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:728:40: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:729:39: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:731:44: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:732:36: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:733:41: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:734:43: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:735:42: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:736:40: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:737:36: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:738:37: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:741:39: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:742:40: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:743:40: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:744:40: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:745:40: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:746:43: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:747:42: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:748:40: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:749:39: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:750:41: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:751:41: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:752:43: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:753:42: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:755:42: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:756:41: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:757:41: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:758:39: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:759:39: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:761:41: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:762:44: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:763:45: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:764:40: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:765:40: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:766:40: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:767:44: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:768:44: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:769:39: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:770:35: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:771:35: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:772:37: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:773:39: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:774:45: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:775:41: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:776:39: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:803:34: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:841:30: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:842:37: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:982:40: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:984:46: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1209:36: casting `i32` to `i16` may truncate the value
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1210:36: casting `i32` to `i16` may truncate the value
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1235:39: integer type suffix should be separated by an underscore
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1236:41: integer type suffix should be separated by an underscore
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1274:42: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1324:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1333:37: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1334:35: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1346:34: casting `u32` to `i32` may wrap around the value
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1346:34: integer type suffix should be separated by an underscore
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1346:34: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1347:37: casting `u32` to `i32` may wrap around the value
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1347:37: integer type suffix should be separated by an underscore
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1347:37: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1348:36: casting `u32` to `i32` may wrap around the value
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1348:36: integer type suffix should be separated by an underscore
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1348:36: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1349:37: casting `u32` to `i32` may wrap around the value
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1349:37: integer type suffix should be separated by an underscore
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1349:37: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1350:35: casting `u32` to `i32` may wrap around the value
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1350:35: integer type suffix should be separated by an underscore
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1350:35: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1351:36: casting `u32` to `i32` may wrap around the value
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1351:36: integer type suffix should be separated by an underscore
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1351:36: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1352:31: casting `u32` to `i32` may wrap around the value
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1352:31: integer type suffix should be separated by an underscore
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1352:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1419:36: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1420:36: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1421:36: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1422:36: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1423:36: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1490:37: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1561:46: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1562:45: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1567:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1568:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1586:26: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1587:34: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1588:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1589:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1897:38: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1898:51: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1900:39: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1969:34: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1970:34: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1971:36: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1972:36: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1973:36: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1974:37: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1975:37: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1976:36: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1977:36: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1978:39: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1979:39: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1980:39: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1981:39: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1982:39: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1983:39: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1984:38: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1985:38: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1986:35: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1987:35: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1988:35: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1989:35: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1990:38: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1991:37: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1992:37: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1993:38: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1994:37: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1995:37: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1996:37: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1997:37: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1998:33: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1999:33: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2000:33: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2001:34: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2002:34: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2003:34: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2004:35: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2005:35: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2032:30: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2033:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2034:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2035:29: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2036:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2037:28: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2038:27: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2039:29: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2041:29: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2042:28: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2043:27: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2044:34: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2045:27: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2046:33: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2048:28: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2049:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2050:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2051:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2052:26: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2053:36: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2318:42: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2321:38: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2331:39: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2487:42: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2488:42: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2489:43: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2490:43: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2491:43: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2493:47: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2494:44: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2495:46: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2496:47: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2497:49: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2498:48: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2499:50: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2500:45: long literal lacking separators
 libc-0.2.81/src/unix/linux_like/linux/mod.rs:2572:9: unneeded `return` statement
 libc-0.2.81/src/unix/linux_like/linux/mod.rs:2578:20: `0 as *mut _` detected
 libc-0.2.81/src/unix/linux_like/linux/mod.rs:2588:13: `0 as *mut _` detected
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2596:52: used binding `_dummy` which is prefixed with an underscore. A leading underscore signals that a binding will not be used.
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2597:11: casting `i32` to `usize` may lose the sign of the value
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2601:21: it is more concise to loop over references to containers instead of using explicit iteration methods
 libc-0.2.81/src/unix/linux_like/linux/mod.rs:2611:9: unneeded unit expression
 libc-0.2.81/src/unix/linux_like/linux/mod.rs:2619:9: unneeded unit expression
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2634:9: casting `u32` to `i32` may wrap around the value
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2647:25: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2648:25: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2649:9: casting `u64` to `u32` may truncate the value
 libc-0.2.81/src/unix/linux_like/linux/mod.rs:2654:18: the operation is ineffective. Consider reducing it to `(dev & 0x00000000000000ff)`
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2654:25: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2655:25: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2656:9: casting `u64` to `u32` may truncate the value
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2660:21: casting `u32` to `u64` may become silently lossy if you later change the type
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2661:21: casting `u32` to `u64` may become silently lossy if you later change the type
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2663:25: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2664:25: long literal lacking separators
 libc-0.2.81/src/unix/linux_like/linux/mod.rs:2665:16: the operation is ineffective. Consider reducing it to `(minor & 0x000000ff)`
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2665:25: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2666:25: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:40:1: enum with no variants
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:954:34: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1000:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1001:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1002:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1016:29: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1017:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1018:33: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1019:33: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1020:33: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1029:29: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1030:29: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1031:30: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1032:29: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1033:29: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1034:29: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1035:29: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1041:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1042:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1043:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1044:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1045:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1046:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1047:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1048:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1049:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1050:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1051:33: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1053:29: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1054:33: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1055:30: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1056:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1057:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1058:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1059:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1060:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1073:42: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1074:43: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1075:37: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1076:37: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1077:41: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1078:35: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1079:35: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1080:36: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1081:35: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1082:35: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1083:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1084:38: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1086:30: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1087:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1089:30: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1090:33: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1091:30: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1094:40: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1095:37: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1096:41: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1097:40: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1098:39: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1099:34: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1100:36: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1101:38: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1102:37: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1105:44: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1106:41: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1107:42: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1108:42: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1109:41: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1110:46: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1111:41: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1112:44: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1113:40: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1114:47: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1115:36: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1126:34: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1127:29: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1128:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1179:32: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:1180:31: long literal lacking separators
 libc-0.2.81/src/unix/linux_like/mod.rs:1218:27: the operation is ineffective. Consider reducing it to `IPOPT_CONTROL`
 libc-0.2.81/src/unix/linux_like/mod.rs:1314:9: operator precedence can trip the unwary
 libc-0.2.81/src/unix/linux_like/mod.rs:1323:13: `0 as *mut _` detected
+libc-0.2.81/src/unix/linux_like/mod.rs:1332:9: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+libc-0.2.81/src/unix/linux_like/mod.rs:1337:9: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+libc-0.2.81/src/unix/linux_like/mod.rs:1341:18: casting `i32` to `usize` may lose the sign of the value
 libc-0.2.81/src/unix/linux_like/mod.rs:1344:9: unneeded `return` statement
+libc-0.2.81/src/unix/linux_like/mod.rs:1348:18: casting `i32` to `usize` may lose the sign of the value
 libc-0.2.81/src/unix/linux_like/mod.rs:1350:9: unneeded `return` statement
+libc-0.2.81/src/unix/linux_like/mod.rs:1354:18: casting `i32` to `usize` may lose the sign of the value
 libc-0.2.81/src/unix/linux_like/mod.rs:1357:9: unneeded `return` statement
+libc-0.2.81/src/unix/linux_like/mod.rs:1361:21: it is more concise to loop over references to containers instead of using explicit iteration methods
+libc-0.2.81/src/unix/linux_like/mod.rs:1381:9: casting `i32` to `i8` may truncate the value
+libc-0.2.81/src/unix/linux_like/mod.rs:1389:9: bit mask could be simplified with a call to `trailing_zeros`
+libc-0.2.81/src/unix/linux_like/mod.rs:446:31: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:591:36: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:592:38: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:593:35: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:594:33: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:595:34: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:596:36: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:597:37: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:598:37: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:599:39: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:600:34: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:601:35: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:602:35: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:607:37: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:608:35: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:764:35: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:765:39: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:991:30: long literal lacking separators
+libc-0.2.81/src/unix/linux_like/mod.rs:9:1: enum with no variants
+libc-0.2.81/src/unix/mod.rs:198:29: long literal lacking separators
+libc-0.2.81/src/unix/mod.rs:199:28: long literal lacking separators
 libc-0.2.81/src/unix/mod.rs:201:35: casting integer literal to `usize` is unnecessary
 libc-0.2.81/src/unix/mod.rs:202:35: casting integer literal to `usize` is unnecessary
+libc-0.2.81/src/unix/mod.rs:282:40: long literal lacking separators
+libc-0.2.81/src/unix/mod.rs:284:41: long literal lacking separators
+libc-0.2.81/src/unix/mod.rs:285:36: long literal lacking separators
+libc-0.2.81/src/unix/mod.rs:34:1: enum with no variants
+libc-0.2.81/src/unix/mod.rs:386:1: enum with no variants
+libc-0.2.81/src/unix/mod.rs:394:1: enum with no variants
+quote-1.0.7/src/ext.rs:10:1: item name ends with its containing module's name
+quote-1.0.7/src/ext.rs:7:5: you should put `TokenStream` between ticks in the documentation
+quote-1.0.7/src/ident_fragment.rs:13:5: docs for function returning `Result` missing `# Errors` section
 quote-1.0.7/src/ident_fragment.rs:51:31: stripping a prefix manually
+quote-1.0.7/src/runtime.rs:52:5: item name ends with its containing module's name
+quote-1.0.7/src/runtime.rs:63:5: item name ends with its containing module's name
+quote-1.0.7/src/runtime.rs:66:33: you should put `DoesNotHaveIter` between ticks in the documentation
+quote-1.0.7/src/runtime.rs:80:5: item name ends with its containing module's name
+rand_core-0.6.0/src/block.rs:117:1: item name starts with its containing module's name
+rand_core-0.6.0/src/block.rs:153:5: you have declared `#[inline(always)]` on `index`. This is usually a bad idea
+rand_core-0.6.0/src/block.rs:230:5: you have declared `#[inline(always)]` on `try_fill_bytes`. This is usually a bad idea
+rand_core-0.6.0/src/block.rs:240:5: you have declared `#[inline(always)]` on `from_seed`. This is usually a bad idea
+rand_core-0.6.0/src/block.rs:245:5: you have declared `#[inline(always)]` on `seed_from_u64`. This is usually a bad idea
+rand_core-0.6.0/src/block.rs:250:5: you have declared `#[inline(always)]` on `from_rng`. This is usually a bad idea
+rand_core-0.6.0/src/block.rs:280:1: item name starts with its containing module's name
+rand_core-0.6.0/src/block.rs:319:5: you have declared `#[inline(always)]` on `index`. This is usually a bad idea
+rand_core-0.6.0/src/block.rs:405:5: you have declared `#[inline(always)]` on `try_fill_bytes`. This is usually a bad idea
+rand_core-0.6.0/src/block.rs:415:5: you have declared `#[inline(always)]` on `from_seed`. This is usually a bad idea
+rand_core-0.6.0/src/block.rs:420:5: you have declared `#[inline(always)]` on `seed_from_u64`. This is usually a bad idea
+rand_core-0.6.0/src/block.rs:425:5: you have declared `#[inline(always)]` on `from_rng`. This is usually a bad idea
+rand_core-0.6.0/src/block.rs:67:14: you should put `module][crate::block` between ticks in the documentation
+rand_core-0.6.0/src/block.rs:68:1: item name starts with its containing module's name
+rand_core-0.6.0/src/error.rs:106:5: this method could have a `#[must_use]` attribute
+rand_core-0.6.0/src/error.rs:87:5: this method could have a `#[must_use]` attribute
+rand_core-0.6.0/src/error.rs:95:74: casting `u32` to `i32` may wrap around the value
+rand_core-0.6.0/src/lib.rs:179:5: docs for function returning `Result` missing `# Errors` section
+rand_core-0.6.0/src/lib.rs:301:5: this method could have a `#[must_use]` attribute
+rand_core-0.6.0/src/lib.rs:303:26: long literal lacking separators
+rand_core-0.6.0/src/lib.rs:304:26: long literal lacking separators
+rand_core-0.6.0/src/lib.rs:313:30: casting `u64` to `u32` may truncate the value
+rand_core-0.6.0/src/lib.rs:314:23: casting `u64` to `u32` may truncate the value
+rand_core-0.6.0/src/lib.rs:346:5: docs for function returning `Result` missing `# Errors` section
+rand_core-0.6.0/src/lib.rs:381:5: you have declared `#[inline(always)]` on `next_u32`. This is usually a bad idea
+rand_core-0.6.0/src/lib.rs:386:5: you have declared `#[inline(always)]` on `next_u64`. This is usually a bad idea
+rand_core-0.6.0/src/lib.rs:391:5: you have declared `#[inline(always)]` on `fill_bytes`. This is usually a bad idea
+rand_core-0.6.0/src/lib.rs:396:5: you have declared `#[inline(always)]` on `try_fill_bytes`. This is usually a bad idea
+unicode-xid-0.2.1/src/lib.rs:57:64: you should put `XID_Start` between ticks in the documentation
+unicode-xid-0.2.1/src/lib.rs:60:10: you should put `XID_Start` between ticks in the documentation
+unicode-xid-0.2.1/src/lib.rs:62:27: you should put `ID_Start` between ticks in the documentation
+unicode-xid-0.2.1/src/lib.rs:62:67: you should put `NFKx` between ticks in the documentation
+unicode-xid-0.2.1/src/lib.rs:65:61: you should put `XID_Continue` between ticks in the documentation
+unicode-xid-0.2.1/src/lib.rs:68:10: you should put `XID_Continue` between ticks in the documentation
+unicode-xid-0.2.1/src/lib.rs:70:28: you should put `ID_Continue` between ticks in the documentation
+unicode-xid-0.2.1/src/lib.rs:70:72: you should put `NFKx` between ticks in the documentation
+proc-macro2-1.0.24/src/detection.rs:2:5: usage of wildcard import
+proc-macro2-1.0.24/src/fallback.rs:108:17: wildcard match will miss any future added variants
+proc-macro2-1.0.24/src/fallback.rs:269:20: unused `self` argument
+proc-macro2-1.0.24/src/fallback.rs:430:24: this argument (0 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+proc-macro2-1.0.24/src/fallback.rs:437:23: this argument (0 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+proc-macro2-1.0.24/src/fallback.rs:437:23: unused `self` argument
+proc-macro2-1.0.24/src/fallback.rs:471:17: this argument (0 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+proc-macro2-1.0.24/src/fallback.rs:471:17: unused `self` argument
 proc-macro2-1.0.24/src/fallback.rs:654:5: manual `RangeInclusive::contains` implementation
 proc-macro2-1.0.24/src/fallback.rs:655:12: manual `RangeInclusive::contains` implementation
 proc-macro2-1.0.24/src/fallback.rs:661:5: manual `RangeInclusive::contains` implementation
 proc-macro2-1.0.24/src/fallback.rs:662:12: manual `RangeInclusive::contains` implementation
 proc-macro2-1.0.24/src/fallback.rs:664:12: manual `RangeInclusive::contains` implementation
 proc-macro2-1.0.24/src/fallback.rs:674:37: manual `RangeInclusive::contains` implementation
+proc-macro2-1.0.24/src/fallback.rs:678:5: adding items after statements is confusing, since items exist from the start of the scope
+proc-macro2-1.0.24/src/fallback.rs:85:9: adding items after statements is confusing, since items exist from the start of the scope
+proc-macro2-1.0.24/src/fallback.rs:882:43: unused `self` argument
+proc-macro2-1.0.24/src/lib.rs:1017:9: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:1081:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:1099:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:1117:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:1135:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:1141:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:1146:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:1151:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:1156:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:152:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:157:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:373:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:383:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:397:24: this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+proc-macro2-1.0.24/src/lib.rs:397:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:403:23: this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+proc-macro2-1.0.24/src/lib.rs:403:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:418:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:425:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:464:17: this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+proc-macro2-1.0.24/src/lib.rs:500:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:626:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:633:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:641:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:652:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:662:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:672:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:734:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:743:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:752:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:757:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:788:19: you should put `XID_Start` between ticks in the documentation
+proc-macro2-1.0.24/src/lib.rs:788:69: you should put `XID_Continue` between ticks in the documentation
+proc-macro2-1.0.24/src/lib.rs:891:36: you should put `syn::parse_str` between ticks in the documentation
+proc-macro2-1.0.24/src/lib.rs:894:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:911:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:996:9: this method could have a `#[must_use]` attribute
 proc-macro2-1.0.24/src/parse.rs:552:5: this loop could be written as a `for` loop
 proc-macro2-1.0.24/src/parse.rs:584:21: manual `RangeInclusive::contains` implementation
+proc-macro2-1.0.24/src/parse.rs:602:20: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
+proc-macro2-1.0.24/src/parse.rs:696:29: casting `u8` to `u64` may become silently lossy if you later change the type
+proc-macro2-1.0.24/src/parse.rs:702:34: casting `u8` to `u64` may become silently lossy if you later change the type
+proc-macro2-1.0.24/src/parse.rs:708:34: casting `u8` to `u64` may become silently lossy if you later change the type
+proc-macro2-1.0.24/src/parse.rs:803:15: it is more concise to loop over references to containers instead of using explicit iteration methods
+proc-macro2-1.0.24/src/parse.rs:808:15: it is more concise to loop over references to containers instead of using explicit iteration methods
+proc-macro2-1.0.24/src/wrapper.rs:415:24: this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+proc-macro2-1.0.24/src/wrapper.rs:429:23: this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+proc-macro2-1.0.24/src/wrapper.rs:492:17: this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+log-0.4.11/src/lib.rs:1047:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:1053:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:1059:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:1093:5: this method could have a `#[must_use]` attribute
 log-0.4.11/src/lib.rs:1093:5: you should consider adding a `Default` implementation for `MetadataBuilder<'a>`
+log-0.4.11/src/lib.rs:1118:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:1177:1: you have declared `#[inline(always)]` on `max_level`. This is usually a bad idea
+log-0.4.11/src/lib.rs:1178:1: this function could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:1306:1: docs for function returning `Result` missing `# Errors` section
+log-0.4.11/src/lib.rs:1358:1: this function could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:1359:5: unnecessary `!=` operation
+log-0.4.11/src/lib.rs:1407:1: this function could have a `#[must_use]` attribute
 log-0.4.11/src/lib.rs:329:27: you are deriving `Hash` but have implemented `PartialEq` explicitly
+log-0.4.11/src/lib.rs:356:1: you are implementing `Clone` explicitly on a `Copy` type
 log-0.4.11/src/lib.rs:448:12: manual `RangeInclusive::contains` implementation
+log-0.4.11/src/lib.rs:468:13: called `filter(..).map(..)` on an `Iterator`
+log-0.4.11/src/lib.rs:500:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:506:28: this argument (8 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+log-0.4.11/src/lib.rs:506:5: this method could have a `#[must_use]` attribute
 log-0.4.11/src/lib.rs:520:27: you are deriving `Hash` but have implemented `PartialEq` explicitly
+log-0.4.11/src/lib.rs:538:1: you are implementing `Clone` explicitly on a `Copy` type
+log-0.4.11/src/lib.rs:653:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:661:21: this argument (8 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+log-0.4.11/src/lib.rs:661:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:677:44: this `match` has identical arm bodies
+log-0.4.11/src/lib.rs:758:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:764:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:770:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:776:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:782:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:788:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:794:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:803:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:809:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:818:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:908:5: this method could have a `#[must_use]` attribute
 log-0.4.11/src/lib.rs:908:5: you should consider adding a `Default` implementation for `RecordBuilder<'a>`
+log-0.4.11/src/lib.rs:995:5: this method could have a `#[must_use]` attribute
 regex-1.4.2/src/backtrack.rs:100:13: redundant field names in struct initialization
 regex-1.4.2/src/backtrack.rs:133:17: it looks like the same item is being pushed into this Vec
+regex-1.4.2/src/backtrack.rs:145:20: unnecessary boolean `not` operation
+regex-1.4.2/src/backtrack.rs:199:13: usage of wildcard import for enum variants
 regex-1.4.2/src/backtrack.rs:223:29: redundant field names in struct initialization
 regex-1.4.2/src/backtrack.rs:230:66: redundant field names in struct initialization
+regex-1.4.2/src/backtrack.rs:284:21: casting `u32` to `u64` may become silently lossy if you later change the type
+regex-1.4.2/src/backtrack.rs:287:5: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
 regex-1.4.2/src/backtrack.rs:97:13: redundant field names in struct initialization
 regex-1.4.2/src/backtrack.rs:98:13: redundant field names in struct initialization
 regex-1.4.2/src/backtrack.rs:99:13: redundant field names in struct initialization
 regex-1.4.2/src/compile.rs:1000:17: redundant field names in struct initialization
+regex-1.4.2/src/compile.rs:103:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/compile.rs:1048:17: you should put `HashMap` between ticks in the documentation
+regex-1.4.2/src/compile.rs:1075:26: integer type suffix should be separated by an underscore
 regex-1.4.2/src/compile.rs:1089:44: redundant field names in struct initialization
 regex-1.4.2/src/compile.rs:1089:54: redundant field names in struct initialization
+regex-1.4.2/src/compile.rs:1100:32: long literal lacking separators
+regex-1.4.2/src/compile.rs:1101:21: long literal lacking separators
+regex-1.4.2/src/compile.rs:1103:18: casting `u8` to `u64` may become silently lossy if you later change the type
+regex-1.4.2/src/compile.rs:1104:18: casting `u8` to `u64` may become silently lossy if you later change the type
+regex-1.4.2/src/compile.rs:1105:9: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
+regex-1.4.2/src/compile.rs:1132:37: casting `u16` to `u8` may truncate the value
+regex-1.4.2/src/compile.rs:1132:55: casting `u16` to `u8` may truncate the value
+regex-1.4.2/src/compile.rs:1135:28: casting `u16` to `u8` may truncate the value
+regex-1.4.2/src/compile.rs:1135:38: casting `u16` to `u8` may truncate the value
+regex-1.4.2/src/compile.rs:113:5: docs for function returning `Result` missing `# Errors` section
+regex-1.4.2/src/compile.rs:1146:25: integer type suffix should be separated by an underscore
+regex-1.4.2/src/compile.rs:1166:8: casting `u32` to `u64` may become silently lossy if you later change the type
 regex-1.4.2/src/compile.rs:136:46: use of `unwrap_or` followed by a function call
+regex-1.4.2/src/compile.rs:155:30: redundant closure found
+regex-1.4.2/src/compile.rs:157:30: redundant closure found
 regex-1.4.2/src/compile.rs:172:42: use of `unwrap_or` followed by a function call
 regex-1.4.2/src/compile.rs:180:43: use of `unwrap_or` followed by a function call
 regex-1.4.2/src/compile.rs:188:5: this function's return value is unnecessarily wrapped by `Result`
+regex-1.4.2/src/compile.rs:190:40: redundant closure found
+regex-1.4.2/src/compile.rs:204:53: you should put `MaybeInsts` between ticks in the documentation
+regex-1.4.2/src/compile.rs:244:63: you should put `c_concat` between ticks in the documentation
+regex-1.4.2/src/compile.rs:251:5: this function has too many lines (111/100)
+regex-1.4.2/src/compile.rs:253:13: usage of wildcard import for enum variants
 regex-1.4.2/src/compile.rs:375:39: use of `unwrap_or` followed by a function call
 regex-1.4.2/src/compile.rs:379:29: redundant field names in struct initialization
 regex-1.4.2/src/compile.rs:379:41: redundant field names in struct initialization
+regex-1.4.2/src/compile.rs:384:12: unnecessary boolean `not` operation
 regex-1.4.2/src/compile.rs:413:56: redundant field names in struct initialization
 regex-1.4.2/src/compile.rs:421:45: redundant field names in struct initialization
 regex-1.4.2/src/compile.rs:428:51: redundant field names in struct initialization
 regex-1.4.2/src/compile.rs:430:29: redundant field names in struct initialization
 regex-1.4.2/src/compile.rs:438:5: this function's return value is unnecessarily wrapped by `Result`
+regex-1.4.2/src/compile.rs:43:5: this method could have a `#[must_use]` attribute
 regex-1.4.2/src/compile.rs:43:5: you should consider adding a `Default` implementation for `compile::Compiler`
 regex-1.4.2/src/compile.rs:468:5: this function's return value is unnecessarily wrapped by `Result`
 regex-1.4.2/src/compile.rs:469:57: redundant field names in struct initialization
 regex-1.4.2/src/compile.rs:470:25: redundant field names in struct initialization
 regex-1.4.2/src/compile.rs:494:25: redundant field names in struct initialization
 regex-1.4.2/src/compile.rs:494:37: redundant field names in struct initialization
+regex-1.4.2/src/compile.rs:547:13: usage of wildcard import for enum variants
+regex-1.4.2/src/compile.rs:56:57: you should put `size_limit` between ticks in the documentation
+regex-1.4.2/src/compile.rs:59:5: this method could have a `#[must_use]` attribute
 regex-1.4.2/src/compile.rs:637:14: use of `unwrap_or` followed by a function call
+regex-1.4.2/src/compile.rs:638:9: use Option::map_or instead of an if let/else
 regex-1.4.2/src/compile.rs:661:41: use of `unwrap_or` followed by a function call
+regex-1.4.2/src/compile.rs:703:9: you should put `c_function` between ticks in the documentation
+regex-1.4.2/src/compile.rs:75:5: this method could have a `#[must_use]` attribute
 regex-1.4.2/src/compile.rs:786:5: this function's return value is unnecessarily wrapped by `Result`
 regex-1.4.2/src/compile.rs:838:21: redundant field names in struct initialization
 regex-1.4.2/src/compile.rs:845:21: redundant field names in struct initialization
+regex-1.4.2/src/compile.rs:848:13: wildcard match will miss any future added variants
+regex-1.4.2/src/compile.rs:84:5: this method could have a `#[must_use]` attribute
 regex-1.4.2/src/compile.rs:860:41: redundant field names in struct initialization
 regex-1.4.2/src/compile.rs:860:55: redundant field names in struct initialization
 regex-1.4.2/src/compile.rs:920:39: redundant field names in struct initialization
@@ -292,97 +2886,367 @@ regex-1.4.2/src/compile.rs:927:43: redundant field names in struct initializatio
 regex-1.4.2/src/compile.rs:930:41: redundant field names in struct initialization
 regex-1.4.2/src/compile.rs:930:53: redundant field names in struct initialization
 regex-1.4.2/src/compile.rs:930:67: redundant field names in struct initialization
+regex-1.4.2/src/compile.rs:96:5: this method could have a `#[must_use]` attribute
 regex-1.4.2/src/compile.rs:991:5: this function's return value is unnecessarily wrapped by `Result`
+regex-1.4.2/src/dfa.rs:1007:17: binding's name is too similar to existing binding
+regex-1.4.2/src/dfa.rs:1010:22: binding's name is too similar to existing binding
+regex-1.4.2/src/dfa.rs:1059:13: usage of wildcard import for enum variants
+regex-1.4.2/src/dfa.rs:1060:13: usage of wildcard import for enum variants
+regex-1.4.2/src/dfa.rs:1084:38: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+regex-1.4.2/src/dfa.rs:1087:38: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+regex-1.4.2/src/dfa.rs:1090:38: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+regex-1.4.2/src/dfa.rs:1093:38: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+regex-1.4.2/src/dfa.rs:1096:38: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+regex-1.4.2/src/dfa.rs:1101:38: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+regex-1.4.2/src/dfa.rs:1104:38: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+regex-1.4.2/src/dfa.rs:1107:38: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+regex-1.4.2/src/dfa.rs:1117:30: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+regex-1.4.2/src/dfa.rs:1120:47: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+regex-1.4.2/src/dfa.rs:1121:30: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+regex-1.4.2/src/dfa.rs:1129:13: you should put `is_match` between ticks in the documentation
+regex-1.4.2/src/dfa.rs:1134:13: you should put `is_match` between ticks in the documentation
+regex-1.4.2/src/dfa.rs:1185:68: you should put `is_match` between ticks in the documentation
+regex-1.4.2/src/dfa.rs:1193:13: usage of wildcard import for enum variants
+regex-1.4.2/src/dfa.rs:1244:50: you should put `current_state` between ticks in the documentation
+regex-1.4.2/src/dfa.rs:1338:58: you should put `STATE_DEAD` between ticks in the documentation
+regex-1.4.2/src/dfa.rs:1339:9: you should put `STATE_UNKNOWN` between ticks in the documentation
+regex-1.4.2/src/dfa.rs:1366:25: you should put `STATE_DEAD` between ticks in the documentation
+regex-1.4.2/src/dfa.rs:1366:46: you should put `STATE_UNKNOWN` between ticks in the documentation
+regex-1.4.2/src/dfa.rs:1367:41: you have declared `#[inline(always)]` on `start_state`. This is usually a bad idea
 regex-1.4.2/src/dfa.rs:1380:14: the operation is ineffective. Consider reducing it to `(empty_flags.start as u8)`
+regex-1.4.2/src/dfa.rs:1388:15: indexing into a vector may panic
+regex-1.4.2/src/dfa.rs:1412:20: unused `self` argument
+regex-1.4.2/src/dfa.rs:1438:9: unused `self` argument
+regex-1.4.2/src/dfa.rs:1472:9: you should put `StatePtr` between ticks in the documentation
+regex-1.4.2/src/dfa.rs:1490:54: casting `i32` to `u8` may lose the sign of the value
+regex-1.4.2/src/dfa.rs:1490:54: casting `i32` to `u8` may truncate the value
+regex-1.4.2/src/dfa.rs:1521:20: you should put `num_byte_classes` between ticks in the documentation
+regex-1.4.2/src/dfa.rs:1529:41: you have declared `#[inline(always)]` on `byte_class`. This is usually a bad idea
+regex-1.4.2/src/dfa.rs:1537:14: you should put `byte_class` between ticks in the documentation
+regex-1.4.2/src/dfa.rs:1538:41: you have declared `#[inline(always)]` on `u8_class`. This is usually a bad idea
+regex-1.4.2/src/dfa.rs:1562:18: you should put `STATE_START` between ticks in the documentation
 regex-1.4.2/src/dfa.rs:1614:13: redundant field names in struct initialization
 regex-1.4.2/src/dfa.rs:1651:38: redundant field names in struct initialization
+regex-1.4.2/src/dfa.rs:1700:17: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
 regex-1.4.2/src/dfa.rs:1701:18: digits of hex or binary literal not grouped by four
 regex-1.4.2/src/dfa.rs:1705:19: digits of hex or binary literal not grouped by four
+regex-1.4.2/src/dfa.rs:1708:16: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
 regex-1.4.2/src/dfa.rs:1709:18: digits of hex or binary literal not grouped by four
 regex-1.4.2/src/dfa.rs:1713:19: digits of hex or binary literal not grouped by four
+regex-1.4.2/src/dfa.rs:1716:18: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
 regex-1.4.2/src/dfa.rs:1717:18: digits of hex or binary literal not grouped by four
 regex-1.4.2/src/dfa.rs:1721:19: digits of hex or binary literal not grouped by four
+regex-1.4.2/src/dfa.rs:1727:14: casting `u8` to `u16` may become silently lossy if you later change the type
+regex-1.4.2/src/dfa.rs:1732:15: this argument (2 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+regex-1.4.2/src/dfa.rs:1736:22: this argument (2 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
 regex-1.4.2/src/dfa.rs:1741:9: match expression looks like `matches!` macro
+regex-1.4.2/src/dfa.rs:1747:16: this argument (2 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+regex-1.4.2/src/dfa.rs:1751:18: casting `u16` to `u8` may truncate the value
+regex-1.4.2/src/dfa.rs:1815:38: casting `usize` to `u8` may truncate the value
+regex-1.4.2/src/dfa.rs:1821:21: casting `u32` to `u64` may become silently lossy if you later change the type
+regex-1.4.2/src/dfa.rs:1824:5: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+regex-1.4.2/src/dfa.rs:1848:5: you should put bare URLs between `<`/`>` or make a proper Markdown link
+regex-1.4.2/src/dfa.rs:1850:18: casting `i32` to `u32` may lose the sign of the value
+regex-1.4.2/src/dfa.rs:1857:5: you should put bare URLs between `<`/`>` or make a proper Markdown link
+regex-1.4.2/src/dfa.rs:1860:17: casting `u32` to `i32` may wrap around the value
+regex-1.4.2/src/dfa.rs:1867:5: you should put bare URLs between `<`/`>` or make a proper Markdown link
+regex-1.4.2/src/dfa.rs:1870:19: casting `u32` to `u8` may truncate the value
+regex-1.4.2/src/dfa.rs:1873:15: casting `u32` to `u8` may truncate the value
+regex-1.4.2/src/dfa.rs:1876:5: you should put bare URLs between `<`/`>` or make a proper Markdown link
+regex-1.4.2/src/dfa.rs:1882:26: casting `u8` to `u32` may become silently lossy if you later change the type
+regex-1.4.2/src/dfa.rs:1884:15: casting `u8` to `u32` may become silently lossy if you later change the type
+regex-1.4.2/src/dfa.rs:277:17: casting `u32` to `i32` may wrap around the value
+regex-1.4.2/src/dfa.rs:277:31: casting `u32` to `i32` may wrap around the value
+regex-1.4.2/src/dfa.rs:295:20: casting `usize` to `i32` may truncate the value on targets with 64-bit wide pointers
+regex-1.4.2/src/dfa.rs:295:20: casting `usize` to `i32` may wrap around the value on targets with 32-bit wide pointers
+regex-1.4.2/src/dfa.rs:299:21: casting `i32` to `usize` may lose the sign of the value
+regex-1.4.2/src/dfa.rs:34:46: you should put bare URLs between `<`/`>` or make a proper Markdown link
+regex-1.4.2/src/dfa.rs:398:1: more than 3 bools in a struct
+regex-1.4.2/src/dfa.rs:446:41: you have declared `#[inline(always)]` on `forward`. This is usually a bad idea
 regex-1.4.2/src/dfa.rs:457:13: redundant field names in struct initialization
 regex-1.4.2/src/dfa.rs:459:13: redundant field names in struct initialization
 regex-1.4.2/src/dfa.rs:460:13: redundant field names in struct initialization
+regex-1.4.2/src/dfa.rs:476:41: you have declared `#[inline(always)]` on `reverse`. This is usually a bad idea
 regex-1.4.2/src/dfa.rs:487:13: redundant field names in struct initialization
 regex-1.4.2/src/dfa.rs:489:13: redundant field names in struct initialization
 regex-1.4.2/src/dfa.rs:490:13: redundant field names in struct initialization
+regex-1.4.2/src/dfa.rs:506:41: you have declared `#[inline(always)]` on `forward_many`. This is usually a bad idea
 regex-1.4.2/src/dfa.rs:518:13: redundant field names in struct initialization
 regex-1.4.2/src/dfa.rs:520:13: redundant field names in struct initialization
+regex-1.4.2/src/dfa.rs:554:41: you have declared `#[inline(always)]` on `exec_at`. This is usually a bad idea
+regex-1.4.2/src/dfa.rs:555:5: this function has too many lines (101/100)
+regex-1.4.2/src/dfa.rs:58:9: usage of wildcard import for enum variants
+regex-1.4.2/src/dfa.rs:667:21: binding's name is too similar to existing binding
+regex-1.4.2/src/dfa.rs:747:41: you have declared `#[inline(always)]` on `exec_at_reverse`. This is usually a bad idea
+regex-1.4.2/src/dfa.rs:795:21: binding's name is too similar to existing binding
+regex-1.4.2/src/dfa.rs:848:9: you should put `next_si` between ticks in the documentation
+regex-1.4.2/src/dfa.rs:852:41: you have declared `#[inline(always)]` on `next_si`. This is usually a bad idea
+regex-1.4.2/src/dfa.rs:885:12: you should put `STATE_DEAD` between ticks in the documentation
+regex-1.4.2/src/dfa.rs:889:9: you should put `STATE_UNKNOWN` between ticks in the documentation
+regex-1.4.2/src/dfa.rs:897:13: usage of wildcard import for enum variants
+regex-1.4.2/src/dfa.rs:979:29: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
 regex-1.4.2/src/error.rs:6:1: this seems like a manual implementation of the non-exhaustive pattern
+regex-1.4.2/src/exec.rs:1000:14: you should put `captures_nfa` between ticks in the documentation
+regex-1.4.2/src/exec.rs:100:1: item name starts with its containing module's name
 regex-1.4.2/src/exec.rs:1028:5: this function has too many arguments (9/7)
+regex-1.4.2/src/exec.rs:1039:13: usage of wildcard import for enum variants
+regex-1.4.2/src/exec.rs:1144:13: usage of wildcard import for enum variants
+regex-1.4.2/src/exec.rs:1179:26: this `match` has identical arm bodies
+regex-1.4.2/src/exec.rs:122:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/exec.rs:1250:41: you have declared `#[inline(always)]` on `searcher`. This is usually a bad idea
+regex-1.4.2/src/exec.rs:1260:41: you have declared `#[inline(always)]` on `searcher_str`. This is usually a bad idea
+regex-1.4.2/src/exec.rs:1270:17: you should put `RegexSet` between ticks in the documentation
+regex-1.4.2/src/exec.rs:1280:17: you should put `RegexSet` between ticks in the documentation
 regex-1.4.2/src/exec.rs:137:9: field assignment outside of initializer for an instance created with Default::default()
+regex-1.4.2/src/exec.rs:142:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/exec.rs:158:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/exec.rs:168:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/exec.rs:181:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/exec.rs:195:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/exec.rs:204:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/exec.rs:210:5: this method could have a `#[must_use]` attribute
 regex-1.4.2/src/exec.rs:245:62: this `if` has identical blocks
+regex-1.4.2/src/exec.rs:251:21: unnecessary boolean `not` operation
 regex-1.4.2/src/exec.rs:262:60: this `if` has identical blocks
+regex-1.4.2/src/exec.rs:268:21: unnecessary boolean `not` operation
 regex-1.4.2/src/exec.rs:278:13: redundant field names in struct initialization
 regex-1.4.2/src/exec.rs:281:13: redundant field names in struct initialization
+regex-1.4.2/src/exec.rs:286:5: docs for function returning `Result` missing `# Errors` section
 regex-1.4.2/src/exec.rs:300:30: redundant field names in struct initialization
+regex-1.4.2/src/exec.rs:308:17: binding's name is too similar to existing binding
 regex-1.4.2/src/exec.rs:329:13: redundant field names in struct initialization
 regex-1.4.2/src/exec.rs:330:13: redundant field names in struct initialization
 regex-1.4.2/src/exec.rs:331:13: redundant field names in struct initialization
 regex-1.4.2/src/exec.rs:334:13: redundant field names in struct initialization
 regex-1.4.2/src/exec.rs:340:19: redundant field names in struct initialization
+regex-1.4.2/src/exec.rs:344:27: unused `self` argument
+regex-1.4.2/src/exec.rs:383:41: you have declared `#[inline(always)]` on `shortest_match_at`. This is usually a bad idea
+regex-1.4.2/src/exec.rs:388:41: you have declared `#[inline(always)]` on `is_match_at`. This is usually a bad idea
+regex-1.4.2/src/exec.rs:393:41: you have declared `#[inline(always)]` on `find_at`. This is usually a bad idea
+regex-1.4.2/src/exec.rs:398:41: you have declared `#[inline(always)]` on `captures_read_at`. This is usually a bad idea
+regex-1.4.2/src/exec.rs:425:41: you have declared `#[inline(always)]` on `shortest_match_at`. This is usually a bad idea
+regex-1.4.2/src/exec.rs:44:1: item name starts with its containing module's name
+regex-1.4.2/src/exec.rs:473:9: you should put `shortest_match(...).is_some` between ticks in the documentation
+regex-1.4.2/src/exec.rs:474:41: you have declared `#[inline(always)]` on `is_match_at`. This is usually a bad idea
+regex-1.4.2/src/exec.rs:524:41: you have declared `#[inline(always)]` on `find_at`. This is usually a bad idea
+regex-1.4.2/src/exec.rs:52:1: item name starts with its containing module's name
+regex-1.4.2/src/exec.rs:686:13: usage of wildcard import for enum variants
+regex-1.4.2/src/exec.rs:727:13: usage of wildcard import for enum variants
+regex-1.4.2/src/exec.rs:767:13: usage of wildcard import for enum variants
+regex-1.4.2/src/exec.rs:783:41: you have declared `#[inline(always)]` on `shortest_dfa`. This is usually a bad idea
+regex-1.4.2/src/exec.rs:791:41: you have declared `#[inline(always)]` on `shortest_dfa_reverse_suffix`. This is usually a bad idea
+regex-1.4.2/src/exec.rs:823:13: usage of wildcard import for enum variants
+regex-1.4.2/src/exec.rs:868:13: usage of wildcard import for enum variants
+regex-1.4.2/src/exec.rs:897:31: you should put `shortest_nfa(...).is_some` between ticks in the documentation
+regex-1.4.2/src/exec.rs:899:9: you should put `shortest_nfa` between ticks in the documentation
+regex-1.4.2/src/exec.rs:905:14: you should put `match_nfa` between ticks in the documentation
+regex-1.4.2/src/exec.rs:930:14: you should put `shortest_nfa` between ticks in the documentation
+regex-1.4.2/src/exec.rs:981:14: you should put `find_nfa` between ticks in the documentation
 regex-1.4.2/src/expand.rs:130:22: this call to `as_ref` does nothing
+regex-1.4.2/src/expand.rs:185:27: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
 regex-1.4.2/src/expand.rs:186:5: match expression looks like `matches!` macro
 regex-1.4.2/src/expand.rs:22:13: calling `push_str()` using a single-character string literal
+regex-1.4.2/src/expand.rs:27:23: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
 regex-1.4.2/src/expand.rs:30:17: calling `push_str()` using a single-character string literal
+regex-1.4.2/src/expand.rs:38:30: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
+regex-1.4.2/src/expand.rs:42:21: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
+regex-1.4.2/src/expand.rs:50:1: item name starts with its containing module's name
+regex-1.4.2/src/expand.rs:69:23: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+regex-1.4.2/src/expand.rs:80:28: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
+regex-1.4.2/src/expand.rs:84:21: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
+regex-1.4.2/src/expand.rs:8:1: item name starts with its containing module's name
+regex-1.4.2/src/input.rs:142:1: item name ends with its containing module's name
+regex-1.4.2/src/input.rs:146:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/input.rs:15:1: item name starts with its containing module's name
 regex-1.4.2/src/input.rs:165:31: redundant field names in struct initialization
+regex-1.4.2/src/input.rs:178:13: usage of wildcard import for enum variants
+regex-1.4.2/src/input.rs:228:1: item name ends with its containing module's name
 regex-1.4.2/src/input.rs:236:21: redundant field names in struct initialization
 regex-1.4.2/src/input.rs:236:33: redundant field names in struct initialization
+regex-1.4.2/src/input.rs:24:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/input.rs:271:13: usage of wildcard import for enum variants
+regex-1.4.2/src/input.rs:29:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/input.rs:362:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/input.rs:370:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/input.rs:371:42: redundant closure found
+regex-1.4.2/src/input.rs:37:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/input.rs:388:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/input.rs:42:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/input.rs:47:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/input.rs:53:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/input.rs:58:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/input.rs:63:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/literal/imp.rs:101:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/literal/imp.rs:114:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/literal/imp.rs:127:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/literal/imp.rs:139:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/literal/imp.rs:144:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/literal/imp.rs:149:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/literal/imp.rs:154:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/literal/imp.rs:155:13: usage of wildcard import for enum variants
+regex-1.4.2/src/literal/imp.rs:160:30: this `match` has identical arm bodies
+regex-1.4.2/src/literal/imp.rs:167:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/literal/imp.rs:168:13: usage of wildcard import for enum variants
+regex-1.4.2/src/literal/imp.rs:211:20: redundant else block
+regex-1.4.2/src/literal/imp.rs:276:50: this `match` has identical arm bodies
+regex-1.4.2/src/literal/imp.rs:342:41: you have declared `#[inline(always)]` on `find`. This is usually a bad idea
 regex-1.4.2/src/literal/imp.rs:435:13: redundant field names in struct initialization
 regex-1.4.2/src/literal/imp.rs:436:13: redundant field names in struct initialization
 regex-1.4.2/src/literal/imp.rs:437:13: redundant field names in struct initialization
 regex-1.4.2/src/literal/imp.rs:438:13: redundant field names in struct initialization
 regex-1.4.2/src/literal/imp.rs:439:13: redundant field names in struct initialization
 regex-1.4.2/src/literal/imp.rs:440:13: redundant field names in struct initialization
+regex-1.4.2/src/literal/imp.rs:455:41: you have declared `#[inline(always)]` on `find`. This is usually a bad idea
+regex-1.4.2/src/literal/imp.rs:46:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/literal/imp.rs:481:41: you have declared `#[inline(always)]` on `is_suffix`. This is usually a bad idea
+regex-1.4.2/src/literal/imp.rs:51:5: this method could have a `#[must_use]` attribute
 regex-1.4.2/src/literal/imp.rs:579:13: redundant field names in struct initialization
+regex-1.4.2/src/literal/imp.rs:57:5: this method could have a `#[must_use]` attribute
 regex-1.4.2/src/literal/imp.rs:580:13: redundant field names in struct initialization
 regex-1.4.2/src/literal/imp.rs:583:13: redundant field names in struct initialization
+regex-1.4.2/src/literal/imp.rs:602:9: adding items after statements is confusing, since items exist from the start of the scope
+regex-1.4.2/src/literal/imp.rs:622:24: redundant else block
+regex-1.4.2/src/literal/imp.rs:62:18: this argument is passed by value, but not consumed in the function body
+regex-1.4.2/src/literal/imp.rs:637:24: redundant else block
 regex-1.4.2/src/literal/imp.rs:648:9: unneeded `return` statement
+regex-1.4.2/src/literal/imp.rs:651:44: you should put `BoyerMooreSearch` between ticks in the documentation
 regex-1.4.2/src/literal/imp.rs:65:13: redundant field names in struct initialization
 regex-1.4.2/src/literal/imp.rs:68:13: redundant field names in struct initialization
+regex-1.4.2/src/literal/imp.rs:783:32: redundant else block
 regex-1.4.2/src/literal/imp.rs:786:42: manual saturating arithmetic
+regex-1.4.2/src/literal/imp.rs:78:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/literal/imp.rs:84:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/literal/imp.rs:850:20: long literal lacking separators
+regex-1.4.2/src/literal/imp.rs:85:13: usage of wildcard import for enum variants
 regex-1.4.2/src/pikevm.rs:103:15: redundant field names in struct initialization
 regex-1.4.2/src/pikevm.rs:103:52: redundant field names in struct initialization
 regex-1.4.2/src/pikevm.rs:114:5: this function has too many arguments (8/7)
+regex-1.4.2/src/pikevm.rs:117:13: binding's name is too similar to existing binding
+regex-1.4.2/src/pikevm.rs:124:17: binding's name is too similar to existing binding
+regex-1.4.2/src/pikevm.rs:220:9: you should put `thread_caps` between ticks in the documentation
+regex-1.4.2/src/pikevm.rs:222:16: you should put `at_next` between ticks in the documentation
+regex-1.4.2/src/pikevm.rs:223:9: you should put `at_next` between ticks in the documentation
 regex-1.4.2/src/pikevm.rs:224:5: this function has too many arguments (8/7)
+regex-1.4.2/src/pikevm.rs:234:13: usage of wildcard import for enum variants
+regex-1.4.2/src/pikevm.rs:303:13: usage of wildcard import for enum variants
+regex-1.4.2/src/pikevm.rs:331:29: this expression mutably borrows a mutable reference. Consider reborrowing
 regex-1.4.2/src/pikevm.rs:88:5: this function has too many arguments (8/7)
+regex-1.4.2/src/prog.rs:102:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/prog.rs:113:5: this method could have a `#[must_use]` attribute
 regex-1.4.2/src/prog.rs:120:9: match expression looks like `matches!` macro
+regex-1.4.2/src/prog.rs:128:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/prog.rs:134:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/prog.rs:141:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/prog.rs:147:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/prog.rs:164:41: you have declared `#[inline(always)]` on `deref`. This is usually a bad idea
+regex-1.4.2/src/prog.rs:172:13: usage of wildcard import for enum variants
+regex-1.4.2/src/prog.rs:18:1: more than 3 bools in a struct
 regex-1.4.2/src/prog.rs:236:13: using `write!()` with a format string that ends in a single newline
+regex-1.4.2/src/prog.rs:300:5: this method could have a `#[must_use]` attribute
 regex-1.4.2/src/prog.rs:301:9: match expression looks like `matches!` macro
+regex-1.4.2/src/prog.rs:382:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/prog.rs:409:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/prog.rs:80:5: this method could have a `#[must_use]` attribute
 regex-1.4.2/src/prog.rs:80:5: you should consider adding a `Default` implementation for `prog::Program`
+regex-1.4.2/src/re_builder.rs:267:17: docs for function returning `Result` missing `# Errors` section
+regex-1.4.2/src/re_builder.rs:267:17: docs for function returning `Result` missing `# Errors` section
+regex-1.4.2/src/re_builder.rs:4:1: more than 3 bools in a struct
+regex-1.4.2/src/re_builder.rs:57:17: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/re_builder.rs:57:17: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/re_builder.rs:68:17: docs for function returning `Result` missing `# Errors` section
+regex-1.4.2/src/re_builder.rs:68:17: docs for function returning `Result` missing `# Errors` section
+regex-1.4.2/src/re_bytes.rs:1023:9: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
+regex-1.4.2/src/re_bytes.rs:1045:9: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
 regex-1.4.2/src/re_bytes.rs:1100:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
 regex-1.4.2/src/re_bytes.rs:1125:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
 regex-1.4.2/src/re_bytes.rs:1140:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+regex-1.4.2/src/re_bytes.rs:118:5: docs for function returning `Result` missing `# Errors` section
 regex-1.4.2/src/re_bytes.rs:257:13: redundant field names in struct initialization
+regex-1.4.2/src/re_bytes.rs:29:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/re_bytes.rs:35:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/re_bytes.rs:42:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/re_bytes.rs:48:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/re_bytes.rs:559:29: you should put `shortest_match` between ticks in the documentation
 regex-1.4.2/src/re_bytes.rs:55:33: redundant field names in struct initialization
 regex-1.4.2/src/re_bytes.rs:55:47: redundant field names in struct initialization
+regex-1.4.2/src/re_bytes.rs:573:29: you should put `is_match` between ticks in the documentation
 regex-1.4.2/src/re_bytes.rs:721:13: redundant field names in struct initialization
+regex-1.4.2/src/re_bytes.rs:818:5: you should put `CaptureLocations` between ticks in the documentation
 regex-1.4.2/src/re_bytes.rs:844:1: item `re_bytes::CaptureLocations` has a public `len` method but no corresponding `is_empty` method
+regex-1.4.2/src/re_bytes.rs:850:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/re_bytes.rs:859:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/re_bytes.rs:870:5: this method could have a `#[must_use]` attribute
 regex-1.4.2/src/re_bytes.rs:892:1: item `re_bytes::Captures<'t>` has a public `len` method but no corresponding `is_empty` method
+regex-1.4.2/src/re_bytes.rs:912:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/re_bytes.rs:918:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/re_bytes.rs:927:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/re_bytes.rs:961:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/re_set.rs:108:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/re_set.rs:108:5: this method could have a `#[must_use]` attribute
 regex-1.4.2/src/re_set.rs:192:13: redundant field names in struct initialization
 regex-1.4.2/src/re_set.rs:192:13: redundant field names in struct initialization
+regex-1.4.2/src/re_set.rs:269:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/re_set.rs:269:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/re_set.rs:281:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/re_set.rs:281:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/re_set.rs:286:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/re_set.rs:286:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/re_set.rs:295:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/re_set.rs:295:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/re_set.rs:94:5: docs for function returning `Result` missing `# Errors` section
+regex-1.4.2/src/re_set.rs:94:5: docs for function returning `Result` missing `# Errors` section
 regex-1.4.2/src/re_trait.rs:137:29: redundant field names in struct initialization
+regex-1.4.2/src/re_unicode.rs:1025:9: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
+regex-1.4.2/src/re_unicode.rs:1047:9: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
 regex-1.4.2/src/re_unicode.rs:1095:13: redundant field names in struct initialization
 regex-1.4.2/src/re_unicode.rs:1142:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
 regex-1.4.2/src/re_unicode.rs:1167:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+regex-1.4.2/src/re_unicode.rs:174:5: docs for function returning `Result` missing `# Errors` section
+regex-1.4.2/src/re_unicode.rs:21:1: this function could have a `#[must_use]` attribute
 regex-1.4.2/src/re_unicode.rs:314:13: redundant field names in struct initialization
+regex-1.4.2/src/re_unicode.rs:38:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/re_unicode.rs:44:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/re_unicode.rs:51:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/re_unicode.rs:57:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/re_unicode.rs:618:29: you should put `shortest_match` between ticks in the documentation
+regex-1.4.2/src/re_unicode.rs:632:29: you should put `is_match` between ticks in the documentation
 regex-1.4.2/src/re_unicode.rs:64:33: redundant field names in struct initialization
 regex-1.4.2/src/re_unicode.rs:64:47: redundant field names in struct initialization
+regex-1.4.2/src/re_unicode.rs:835:5: you should put `CaptureLocations` between ticks in the documentation
 regex-1.4.2/src/re_unicode.rs:861:1: item `re_unicode::CaptureLocations` has a public `len` method but no corresponding `is_empty` method
+regex-1.4.2/src/re_unicode.rs:867:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/re_unicode.rs:876:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/re_unicode.rs:887:5: this method could have a `#[must_use]` attribute
 regex-1.4.2/src/re_unicode.rs:909:1: item `re_unicode::Captures<'t>` has a public `len` method but no corresponding `is_empty` method
+regex-1.4.2/src/re_unicode.rs:929:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/re_unicode.rs:935:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/re_unicode.rs:944:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/re_unicode.rs:978:5: this method could have a `#[must_use]` attribute
+regex-1.4.2/src/sparse.rs:11:37: you should put bare URLs between `<`/`>` or make a proper Markdown link
+regex-1.4.2/src/sparse.rs:16:1: item name starts with its containing module's name
 regex-1.4.2/src/utf8.rs:100:16: digits of hex or binary literal not grouped by four
 regex-1.4.2/src/utf8.rs:103:16: digits of hex or binary literal not grouped by four
+regex-1.4.2/src/utf8.rs:106:22: casting `u8` to `u32` may become silently lossy if you later change the type
+regex-1.4.2/src/utf8.rs:107:19: casting `u8` to `u32` may become silently lossy if you later change the type
+regex-1.4.2/src/utf8.rs:108:19: casting `u8` to `u32` may become silently lossy if you later change the type
+regex-1.4.2/src/utf8.rs:109:19: casting `u8` to `u32` may become silently lossy if you later change the type
+regex-1.4.2/src/utf8.rs:111:27: long literal lacking separators
+regex-1.4.2/src/utf8.rs:121:1: item name ends with its containing module's name
 regex-1.4.2/src/utf8.rs:143:24: digits of hex or binary literal not grouped by four
 regex-1.4.2/src/utf8.rs:143:9: digits of hex or binary literal not grouped by four
+regex-1.4.2/src/utf8.rs:23:1: item name ends with its containing module's name
 regex-1.4.2/src/utf8.rs:30:20: digits of hex or binary literal not grouped by four
+regex-1.4.2/src/utf8.rs:51:1: item name ends with its containing module's name
 regex-1.4.2/src/utf8.rs:58:23: digits of hex or binary literal not grouped by four
 regex-1.4.2/src/utf8.rs:58:9: digits of hex or binary literal not grouped by four
 regex-1.4.2/src/utf8.rs:63:16: digits of hex or binary literal not grouped by four
+regex-1.4.2/src/utf8.rs:66:22: casting `u8` to `u32` may become silently lossy if you later change the type
+regex-1.4.2/src/utf8.rs:66:54: casting `u8` to `u32` may become silently lossy if you later change the type
 regex-1.4.2/src/utf8.rs:77:16: digits of hex or binary literal not grouped by four
 regex-1.4.2/src/utf8.rs:80:16: digits of hex or binary literal not grouped by four
+regex-1.4.2/src/utf8.rs:83:22: casting `u8` to `u32` may become silently lossy if you later change the type
+regex-1.4.2/src/utf8.rs:84:19: casting `u8` to `u32` may become silently lossy if you later change the type
+regex-1.4.2/src/utf8.rs:85:19: casting `u8` to `u32` may become silently lossy if you later change the type
 regex-1.4.2/src/utf8.rs:92:23: digits of hex or binary literal not grouped by four
 regex-1.4.2/src/utf8.rs:92:9: digits of hex or binary literal not grouped by four
 regex-1.4.2/src/utf8.rs:97:16: digits of hex or binary literal not grouped by four

From a9fce6d2d0528c9d8cf6390c3e00a3a6099687ce Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= <matthias.krueger@famsik.de>
Date: Fri, 18 Dec 2020 22:53:45 +0100
Subject: [PATCH 086/108] allow clippy::filter_map

---
 clippy_dev/src/crater.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/clippy_dev/src/crater.rs b/clippy_dev/src/crater.rs
index eb301159a7b8a..631499395dfb8 100644
--- a/clippy_dev/src/crater.rs
+++ b/clippy_dev/src/crater.rs
@@ -1,6 +1,9 @@
+#![allow(clippy::filter_map)]
+
 use crate::clippy_project_root;
 use std::path::PathBuf;
 use std::process::Command;
+
 // represents an archive we download from crates.io
 #[derive(Debug)]
 struct KrateSource {

From 588efa7da9af41e79f51935efeb9919ccef97f44 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= <matthias.krueger@famsik.de>
Date: Tue, 22 Dec 2020 13:07:55 +0100
Subject: [PATCH 087/108] use a .toml file to list the crates we want to check

Also sort lint results alphabetically.
---
 clippy_dev/Cargo.toml         |    2 +
 clippy_dev/crater_crates.toml |   20 +
 clippy_dev/src/crater.rs      |   58 +-
 mini-crater/logs.txt          | 2600 ++++++++++++++++-----------------
 4 files changed, 1348 insertions(+), 1332 deletions(-)
 create mode 100644 clippy_dev/crater_crates.toml

diff --git a/clippy_dev/Cargo.toml b/clippy_dev/Cargo.toml
index 517e9d250bca5..6c6941837f121 100644
--- a/clippy_dev/Cargo.toml
+++ b/clippy_dev/Cargo.toml
@@ -11,8 +11,10 @@ flate2 = "1.0.19"
 itertools = "0.9"
 opener = "0.4"
 regex = "1"
+serde = {version = "1.0", features = ["derive"]}
 shell-escape = "0.1"
 tar = "0.4.30"
+toml = "0.5"
 ureq = "2.0.0-rc3"
 walkdir = "2"
 
diff --git a/clippy_dev/crater_crates.toml b/clippy_dev/crater_crates.toml
new file mode 100644
index 0000000000000..e69056c9925d5
--- /dev/null
+++ b/clippy_dev/crater_crates.toml
@@ -0,0 +1,20 @@
+[crates]
+# some of these are from cargotest
+cargo = '0.49.0'
+iron = '0.6.1'
+ripgrep = '12.1.1'
+xsv = '0.13.0'
+#tokei = '12.0.4'
+rayon = '1.5.0'
+serde = '1.0.118'
+# top 10 crates.io dls
+bitflags = '1.2.1'
+libc = '0.2.81'
+log = '0.4.11'
+proc-macro2 = '1.0.24'
+quote = '1.0.7'
+rand = '0.7.3'
+rand_core = '0.6.0'
+regex = '1.3.2'
+syn = '1.0.54'
+unicode-xid = '0.2.1'
diff --git a/clippy_dev/src/crater.rs b/clippy_dev/src/crater.rs
index 631499395dfb8..f64ab897906c3 100644
--- a/clippy_dev/src/crater.rs
+++ b/clippy_dev/src/crater.rs
@@ -1,16 +1,24 @@
 #![allow(clippy::filter_map)]
 
 use crate::clippy_project_root;
-use std::path::PathBuf;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
 use std::process::Command;
+use std::{fs::write, path::PathBuf};
 
 // represents an archive we download from crates.io
-#[derive(Debug)]
+#[derive(Debug, Serialize, Deserialize, Eq, Hash, PartialEq)]
 struct KrateSource {
     version: String,
     name: String,
 }
 
+// use this to store the crates when interacting with the crates.toml file
+#[derive(Debug, Serialize, Deserialize)]
+struct CrateList {
+    crates: HashMap<String, String>,
+}
+
 // represents the extracted sourcecode of a crate
 #[derive(Debug)]
 struct Krate {
@@ -129,33 +137,25 @@ fn build_clippy() {
         .expect("Failed to build clippy!");
 }
 
+// get a list of KrateSources we want to check from a "crater_crates.toml" file.
+fn read_crates() -> Vec<KrateSource> {
+    let toml_path = PathBuf::from("clippy_dev/crater_crates.toml");
+    let toml_content: String =
+        std::fs::read_to_string(&toml_path).unwrap_or_else(|_| panic!("Failed to read {}", toml_path.display()));
+    let crate_list: CrateList =
+        toml::from_str(&toml_content).unwrap_or_else(|e| panic!("Failed to parse {}: \n{}", toml_path.display(), e));
+    // parse the hashmap of the toml file into a list of crates
+    crate_list
+        .crates
+        .iter()
+        .map(|(name, version)| KrateSource::new(&name, &version))
+        .collect()
+}
+
 // the main fn
 pub fn run() {
     let cargo_clippy_path: PathBuf = PathBuf::from("target/debug/cargo-clippy");
 
-    // crates we want to check:
-    let krates: Vec<KrateSource> = vec![
-        // some of these are form cargotest
-        KrateSource::new("cargo", "0.49.0"),
-        KrateSource::new("iron", "0.6.1"),
-        KrateSource::new("ripgrep", "12.1.1"),
-        //KrateSource::new("tokei", "12.0.4"),
-        KrateSource::new("xsv", "0.13.0"),
-        KrateSource::new("serde", "1.0.118"),
-        KrateSource::new("rayon", "1.5.0"),
-        // top 10 crates.io dls
-        KrateSource::new("rand", "0.7.3"),
-        KrateSource::new("syn", "1.0.54"),
-        KrateSource::new("libc", "0.2.81"),
-        KrateSource::new("quote", "1.0.7"),
-        KrateSource::new("rand_core", "0.6.0"),
-        KrateSource::new("unicode-xid", "0.2.1"),
-        KrateSource::new("proc-macro2", "1.0.24"),
-        KrateSource::new("bitflags", "1.2.1"),
-        KrateSource::new("log", "0.4.11"),
-        KrateSource::new("regex", "1.4.2"),
-    ];
-
     println!("Compiling clippy...");
     build_clippy();
     println!("Done compiling");
@@ -168,15 +168,17 @@ pub fn run() {
     );
 
     // download and extract the crates, then run clippy on them and collect clippys warnings
-    let clippy_lint_results: Vec<Vec<String>> = krates
+
+    let clippy_lint_results: Vec<Vec<String>> = read_crates()
         .into_iter()
         .map(|krate| krate.download_and_extract())
         .map(|krate| krate.run_clippy_lints(&cargo_clippy_path))
         .collect();
 
-    let all_warnings: Vec<String> = clippy_lint_results.into_iter().flatten().collect();
+    let mut all_warnings: Vec<String> = clippy_lint_results.into_iter().flatten().collect();
+    all_warnings.sort();
 
     // save the text into mini-crater/logs.txt
     let text = all_warnings.join("");
-    std::fs::write("mini-crater/logs.txt", text).unwrap();
+    write("mini-crater/logs.txt", text).unwrap();
 }
diff --git a/mini-crater/logs.txt b/mini-crater/logs.txt
index 963b1fa38bf54..dfa6450def7f9 100644
--- a/mini-crater/logs.txt
+++ b/mini-crater/logs.txt
@@ -1441,754 +1441,6 @@ iron-0.6.1/src/response.rs:143:5: use of deprecated macro `try`: use the `?` ope
 iron-0.6.1/src/response.rs:24:5: docs for function returning `Result` missing `# Errors` section
 iron-0.6.1/src/response.rs:95:5: this method could have a `#[must_use]` attribute
 iron-0.6.1/src/response.rs:95:5: you should consider adding a `Default` implementation for `response::Response`
-ripgrep-12.1.1/build.rs:133:19: called `.as_ref().map(|x| &**x)` on an Option value. This can be done more directly by calling `githash.as_deref()` instead
-ripgrep-12.1.1/build.rs:18:18: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-ripgrep-12.1.1/build.rs:225:14: redundant closure found
-ripgrep-12.1.1/build.rs:92:19: called `.as_ref().map(|x| &**x)` on an Option value. This can be done more directly by calling `githash.as_deref()` instead
-ripgrep-12.1.1/crates/core/app.rs:1408:5: adding items after statements is confusing, since items exist from the start of the scope
-ripgrep-12.1.1/crates/core/app.rs:1408:5: adding items after statements is confusing, since items exist from the start of the scope
-ripgrep-12.1.1/crates/core/app.rs:1409:5: adding items after statements is confusing, since items exist from the start of the scope
-ripgrep-12.1.1/crates/core/app.rs:1409:5: adding items after statements is confusing, since items exist from the start of the scope
-ripgrep-12.1.1/crates/core/app.rs:152:32: you should put `clap::Arg` between ticks in the documentation
-ripgrep-12.1.1/crates/core/app.rs:152:32: you should put `clap::Arg` between ticks in the documentation
-ripgrep-12.1.1/crates/core/app.rs:156:39: you should put `clap::Arg` between ticks in the documentation
-ripgrep-12.1.1/crates/core/app.rs:156:39: you should put `clap::Arg` between ticks in the documentation
-ripgrep-12.1.1/crates/core/app.rs:156:5: you should put `RGArg` between ticks in the documentation
-ripgrep-12.1.1/crates/core/app.rs:156:5: you should put `RGArg` between ticks in the documentation
-ripgrep-12.1.1/crates/core/app.rs:1668:5: adding items after statements is confusing, since items exist from the start of the scope
-ripgrep-12.1.1/crates/core/app.rs:1668:5: adding items after statements is confusing, since items exist from the start of the scope
-ripgrep-12.1.1/crates/core/app.rs:1669:5: adding items after statements is confusing, since items exist from the start of the scope
-ripgrep-12.1.1/crates/core/app.rs:1669:5: adding items after statements is confusing, since items exist from the start of the scope
-ripgrep-12.1.1/crates/core/app.rs:1821:5: adding items after statements is confusing, since items exist from the start of the scope
-ripgrep-12.1.1/crates/core/app.rs:1821:5: adding items after statements is confusing, since items exist from the start of the scope
-ripgrep-12.1.1/crates/core/app.rs:1822:5: adding items after statements is confusing, since items exist from the start of the scope
-ripgrep-12.1.1/crates/core/app.rs:1822:5: adding items after statements is confusing, since items exist from the start of the scope
-ripgrep-12.1.1/crates/core/app.rs:2999:5: adding items after statements is confusing, since items exist from the start of the scope
-ripgrep-12.1.1/crates/core/app.rs:2999:5: adding items after statements is confusing, since items exist from the start of the scope
-ripgrep-12.1.1/crates/core/app.rs:3000:5: adding items after statements is confusing, since items exist from the start of the scope
-ripgrep-12.1.1/crates/core/app.rs:3000:5: adding items after statements is confusing, since items exist from the start of the scope
-ripgrep-12.1.1/crates/core/app.rs:367:54: this `match` has identical arm bodies
-ripgrep-12.1.1/crates/core/app.rs:367:54: this `match` has identical arm bodies
-ripgrep-12.1.1/crates/core/app.rs:414:59: this `match` has identical arm bodies
-ripgrep-12.1.1/crates/core/app.rs:414:59: this `match` has identical arm bodies
-ripgrep-12.1.1/crates/core/app.rs:417:57: this `match` has identical arm bodies
-ripgrep-12.1.1/crates/core/app.rs:417:57: this `match` has identical arm bodies
-ripgrep-12.1.1/crates/core/app.rs:417:57: this `match` has identical arm bodies
-ripgrep-12.1.1/crates/core/app.rs:417:57: this `match` has identical arm bodies
-ripgrep-12.1.1/crates/core/app.rs:444:41: this `match` has identical arm bodies
-ripgrep-12.1.1/crates/core/app.rs:444:41: this `match` has identical arm bodies
-ripgrep-12.1.1/crates/core/app.rs:470:41: this `match` has identical arm bodies
-ripgrep-12.1.1/crates/core/app.rs:470:41: this `match` has identical arm bodies
-ripgrep-12.1.1/crates/core/app.rs:75:9: you should put `RIPGREP_BUILD_GIT_HASH` between ticks in the documentation
-ripgrep-12.1.1/crates/core/app.rs:75:9: you should put `RIPGREP_BUILD_GIT_HASH` between ticks in the documentation
-ripgrep-12.1.1/crates/core/app.rs:87:5: unnecessary boolean `not` operation
-ripgrep-12.1.1/crates/core/app.rs:87:5: unnecessary boolean `not` operation
-ripgrep-12.1.1/crates/core/args.rs:1143:22: unused `self` argument
-ripgrep-12.1.1/crates/core/args.rs:11:1: this import is redundant
-ripgrep-12.1.1/crates/core/args.rs:1209:74: this `if` has identical blocks
-ripgrep-12.1.1/crates/core/args.rs:1209:74: this `if` has identical blocks
-ripgrep-12.1.1/crates/core/args.rs:1282:13: binding's name is too similar to existing binding
-ripgrep-12.1.1/crates/core/args.rs:1430:22: unused `self` argument
-ripgrep-12.1.1/crates/core/args.rs:1438:21: you should put `OsStr` between ticks in the documentation
-ripgrep-12.1.1/crates/core/args.rs:1520:44: redundant closure found
-ripgrep-12.1.1/crates/core/args.rs:1524:5: this function's return value is unnecessarily wrapped by `Result`
-ripgrep-12.1.1/crates/core/args.rs:1635:14: you should put `values_of_lossy` between ticks in the documentation
-ripgrep-12.1.1/crates/core/args.rs:1693:41: redundant closure found
-ripgrep-12.1.1/crates/core/args.rs:1770:17: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
-ripgrep-12.1.1/crates/core/args.rs:287:13: binding's name is too similar to existing binding
-ripgrep-12.1.1/crates/core/args.rs:33:1: this import is redundant
-ripgrep-12.1.1/crates/core/args.rs:34:1: this import is redundant
-ripgrep-12.1.1/crates/core/args.rs:35:1: this import is redundant
-ripgrep-12.1.1/crates/core/args.rs:410:14: this argument (2 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-ripgrep-12.1.1/crates/core/args.rs:475:18: this `match` has identical arm bodies
-ripgrep-12.1.1/crates/core/args.rs:512:19: you should put `ArgMatches` between ticks in the documentation
-ripgrep-12.1.1/crates/core/args.rs:549:16: methods called `to_*` usually take self by reference; consider choosing a less ambiguous name
-ripgrep-12.1.1/crates/core/args.rs:76:18: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-ripgrep-12.1.1/crates/core/args.rs:77:13: usage of wildcard import for enum variants
-ripgrep-12.1.1/crates/core/args.rs:923:42: you should put `BinaryDetection::quit` between ticks in the documentation
-ripgrep-12.1.1/crates/core/config.rs:13:1: this import is redundant
-ripgrep-12.1.1/crates/core/config.rs:58:6: very complex type used. Consider factoring parts into `type` definitions
-ripgrep-12.1.1/crates/core/config.rs:79:6: very complex type used. Consider factoring parts into `type` definitions
-ripgrep-12.1.1/crates/core/logger.rs:11:30: you should put `max_level` between ticks in the documentation
-ripgrep-12.1.1/crates/core/logger.rs:15:16: constants have by default a `'static` lifetime
-ripgrep-12.1.1/crates/core/main.rs:55:19: this argument is passed by value, but not consumed in the function body
-ripgrep-12.1.1/crates/core/main.rs:56:9: usage of wildcard import for enum variants
-ripgrep-12.1.1/crates/core/messages.rs:46:1: item name ends with its containing module's name
-ripgrep-12.1.1/crates/core/messages.rs:51:1: item name ends with its containing module's name
-ripgrep-12.1.1/crates/core/messages.rs:62:1: item name ends with its containing module's name
-ripgrep-12.1.1/crates/core/path_printer.rs:27:1: item name starts with its containing module's name
-ripgrep-12.1.1/crates/core/path_printer.rs:89:9: unnecessary boolean `not` operation
-ripgrep-12.1.1/crates/core/search.rs:185:1: item name starts with its containing module's name
-ripgrep-12.1.1/crates/core/search.rs:292:9: using `write!()` with a format string that ends in a single newline
-ripgrep-12.1.1/crates/core/search.rs:311:1: item name starts with its containing module's name
-ripgrep-12.1.1/crates/core/search.rs:377:12: this boolean expression can be simplified
-ripgrep-12.1.1/crates/core/search.rs:423:13: usage of wildcard import for enum variants
-ripgrep-12.1.1/crates/core/search.rs:447:13: usage of wildcard import for enum variants
-ripgrep-12.1.1/crates/core/search.rs:472:24: you are using an explicit closure for cloning elements
-ripgrep-12.1.1/crates/core/search.rs:472:41: redundant closure found
-ripgrep-12.1.1/crates/core/search.rs:480:24: you are using an explicit closure for cloning elements
-ripgrep-12.1.1/crates/core/search.rs:480:41: redundant closure found
-ripgrep-12.1.1/crates/core/search.rs:49:1: item name starts with its containing module's name
-ripgrep-12.1.1/crates/core/search.rs:509:24: you are using an explicit closure for cloning elements
-ripgrep-12.1.1/crates/core/search.rs:509:41: redundant closure found
-ripgrep-12.1.1/crates/core/search.rs:517:24: you are using an explicit closure for cloning elements
-ripgrep-12.1.1/crates/core/search.rs:517:41: redundant closure found
-ripgrep-12.1.1/crates/core/search.rs:533:36: casting `u32` to `f64` may become silently lossy if you later change the type
-ripgrep-12.1.1/crates/core/search.rs:533:5: casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-ripgrep-12.1.1/crates/core/subject.rs:20:1: item name starts with its containing module's name
-ripgrep-12.1.1/crates/core/subject.rs:4:1: this import is redundant
-xsv-0.13.0/src/cmd/cat.rs:101:34: redundant closure found
-xsv-0.13.0/src/cmd/cat.rs:42:1: more than 3 bools in a struct
-xsv-0.13.0/src/cmd/cat.rs:53:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/cat.rs:7:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/count.rs:32:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/count.rs:38:9: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-xsv-0.13.0/src/cmd/count.rs:42:33: integer type suffix should be separated by an underscore
-xsv-0.13.0/src/cmd/count.rs:50:5: passing a unit value to a function
-xsv-0.13.0/src/cmd/count.rs:7:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/fixlengths.rs:45:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/fixlengths.rs:50:18: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-xsv-0.13.0/src/cmd/fixlengths.rs:62:30: integer type suffix should be separated by an underscore
-xsv-0.13.0/src/cmd/fixlengths.rs:9:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/flatten.rs:10:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/flatten.rs:51:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/fmt.rs:50:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/fmt.rs:55:13: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/fmt.rs:7:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/frequency.rs:148:43: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
-xsv-0.13.0/src/cmd/frequency.rs:149:43: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
-xsv-0.13.0/src/cmd/frequency.rs:15:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/frequency.rs:169:13: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/frequency.rs:176:17: unnecessary boolean `not` operation
-xsv-0.13.0/src/cmd/frequency.rs:178:24: this `else { if .. }` block can be collapsed
-xsv-0.13.0/src/cmd/frequency.rs:77:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/frequency.rs:93:31: it is more concise to loop over containers instead of using explicit iteration methods
-xsv-0.13.0/src/cmd/headers.rs:43:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/headers.rs:49:17: it is more concise to loop over containers instead of using explicit iteration methods
-xsv-0.13.0/src/cmd/headers.rs:60:22: trait objects without an explicit `dyn` are deprecated
-xsv-0.13.0/src/cmd/headers.rs:9:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/index.rs:11:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/index.rs:45:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/input.rs:42:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/input.rs:47:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/input.rs:7:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/join.rs:17:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/join.rs:194:29: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/join.rs:224:22: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/join.rs:281:44: trait objects without an explicit `dyn` are deprecated
-xsv-0.13.0/src/cmd/join.rs:293:14: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/join.rs:293:20: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/join.rs:297:13: redundant field names in struct initialization
-xsv-0.13.0/src/cmd/join.rs:298:13: redundant field names in struct initialization
-xsv-0.13.0/src/cmd/join.rs:299:13: redundant field names in struct initialization
-xsv-0.13.0/src/cmd/join.rs:300:13: redundant field names in struct initialization
-xsv-0.13.0/src/cmd/join.rs:308:9: unused `self` argument
-xsv-0.13.0/src/cmd/join.rs:342:38: integer type suffix should be separated by an underscore
-xsv-0.13.0/src/cmd/join.rs:342:46: integer type suffix should be separated by an underscore
-xsv-0.13.0/src/cmd/join.rs:347:9: unnecessary boolean `not` operation
-xsv-0.13.0/src/cmd/join.rs:372:44: redundant closure found
-xsv-0.13.0/src/cmd/join.rs:375:33: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/join.rs:392:13: redundant field names in struct initialization
-xsv-0.13.0/src/cmd/join.rs:403:29: it is more concise to loop over containers instead of using explicit iteration methods
-xsv-0.13.0/src/cmd/join.rs:426:13: unnecessary boolean `not` operation
-xsv-0.13.0/src/cmd/join.rs:77:1: more than 3 bools in a struct
-xsv-0.13.0/src/cmd/join.rs:94:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/partition.rs:105:22: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/partition.rs:126:36: trait objects without an explicit `dyn` are deprecated
-xsv-0.13.0/src/cmd/partition.rs:139:13: redundant field names in struct initialization
-xsv-0.13.0/src/cmd/partition.rs:15:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/partition.rs:169:9: unnecessary boolean `not` operation
-xsv-0.13.0/src/cmd/partition.rs:56:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/partition.rs:77:9: unused `self` argument
-xsv-0.13.0/src/cmd/sample.rs:105:44: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
-xsv-0.13.0/src/cmd/sample.rs:115:21: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
-xsv-0.13.0/src/cmd/sample.rs:11:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/sample.rs:51:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/sample.rs:58:19: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-xsv-0.13.0/src/cmd/sample.rs:69:9: wildcard match will miss any future added variants
-xsv-0.13.0/src/cmd/sample.rs:75:16: it is more concise to loop over containers instead of using explicit iteration methods
-xsv-0.13.0/src/cmd/sample.rs:91:42: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
-xsv-0.13.0/src/cmd/sample.rs:92:43: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
-xsv-0.13.0/src/cmd/search.rs:51:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/search.rs:9:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/select.rs:60:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/select.rs:8:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/slice.rs:57:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/slice.rs:9:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/sort.rs:11:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/sort.rs:138:47: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-xsv-0.13.0/src/cmd/sort.rs:139:51: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-xsv-0.13.0/src/cmd/sort.rs:48:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/sort.rs:91:14: it is more concise to loop over containers instead of using explicit iteration methods
-xsv-0.13.0/src/cmd/split.rs:131:36: trait objects without an explicit `dyn` are deprecated
-xsv-0.13.0/src/cmd/split.rs:14:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/split.rs:61:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/split.rs:94:5: this function's return value is unnecessarily wrapped by `Result`
-xsv-0.13.0/src/cmd/split.rs:96:14: this argument is passed by value, but not consumed in the function body
-xsv-0.13.0/src/cmd/split.rs:99:13: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
-xsv-0.13.0/src/cmd/stats.rs:110:36: redundant closure found
-xsv-0.13.0/src/cmd/stats.rs:127:14: this argument is passed by value, but not consumed in the function body
-xsv-0.13.0/src/cmd/stats.rs:138:43: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
-xsv-0.13.0/src/cmd/stats.rs:139:43: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
-xsv-0.13.0/src/cmd/stats.rs:162:25: it is more concise to loop over containers instead of using explicit iteration methods
-xsv-0.13.0/src/cmd/stats.rs:22:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/stats.rs:231:1: more than 3 bools in a struct
-xsv-0.13.0/src/cmd/stats.rs:262:35: calling `cmd::stats::TypedSum::default()` is more clear than this expression
-xsv-0.13.0/src/cmd/stats.rs:263:40: calling `cmd::stats::TypedMinMax::default()` is more clear than this expression
-xsv-0.13.0/src/cmd/stats.rs:264:39: calling `stats::OnlineStats::default()` is more clear than this expression
-xsv-0.13.0/src/cmd/stats.rs:265:58: calling `stats::Unsorted::default()` is more clear than this expression
-xsv-0.13.0/src/cmd/stats.rs:266:41: calling `stats::Unsorted::default()` is more clear than this expression
-xsv-0.13.0/src/cmd/stats.rs:268:18: calling `cmd::stats::FieldType::default()` is more clear than this expression
-xsv-0.13.0/src/cmd/stats.rs:269:13: redundant field names in struct initialization
-xsv-0.13.0/src/cmd/stats.rs:270:13: redundant field names in struct initialization
-xsv-0.13.0/src/cmd/stats.rs:271:13: redundant field names in struct initialization
-xsv-0.13.0/src/cmd/stats.rs:272:13: redundant field names in struct initialization
-xsv-0.13.0/src/cmd/stats.rs:273:13: redundant field names in struct initialization
-xsv-0.13.0/src/cmd/stats.rs:274:13: redundant field names in struct initialization
-xsv-0.13.0/src/cmd/stats.rs:283:9: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-xsv-0.13.0/src/cmd/stats.rs:284:9: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-xsv-0.13.0/src/cmd/stats.rs:285:9: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-xsv-0.13.0/src/cmd/stats.rs:290:21: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-xsv-0.13.0/src/cmd/stats.rs:293:25: this `match` has identical arm bodies
-xsv-0.13.0/src/cmd/stats.rs:297:25: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-xsv-0.13.0/src/cmd/stats.rs:301:21: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-xsv-0.13.0/src/cmd/stats.rs:302:21: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-xsv-0.13.0/src/cmd/stats.rs:308:18: methods called `to_*` usually take self by reference; consider choosing a less ambiguous name
-xsv-0.13.0/src/cmd/stats.rs:318:9: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-xsv-0.13.0/src/cmd/stats.rs:322:45: redundant closure found
-xsv-0.13.0/src/cmd/stats.rs:322:9: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-xsv-0.13.0/src/cmd/stats.rs:327:9: unnecessary boolean `not` operation
-xsv-0.13.0/src/cmd/stats.rs:330:13: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-xsv-0.13.0/src/cmd/stats.rs:338:45: redundant closure found
-xsv-0.13.0/src/cmd/stats.rs:402:16: redundant pattern matching, consider using `is_ok()`
-xsv-0.13.0/src/cmd/stats.rs:403:16: redundant pattern matching, consider using `is_ok()`
-xsv-0.13.0/src/cmd/stats.rs:407:18: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-xsv-0.13.0/src/cmd/stats.rs:411:16: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-xsv-0.13.0/src/cmd/stats.rs:427:56: this `match` has identical arm bodies
-xsv-0.13.0/src/cmd/stats.rs:429:56: this `match` has identical arm bodies
-xsv-0.13.0/src/cmd/stats.rs:430:60: this `match` has identical arm bodies
-xsv-0.13.0/src/cmd/stats.rs:430:60: this `match` has identical arm bodies
-xsv-0.13.0/src/cmd/stats.rs:454:5: you should put `TypedSum` between ticks in the documentation
-xsv-0.13.0/src/cmd/stats.rs:473:43: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-xsv-0.13.0/src/cmd/stats.rs:504:56: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-xsv-0.13.0/src/cmd/stats.rs:505:51: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-xsv-0.13.0/src/cmd/stats.rs:511:5: you should put `TypedMinMax` between ticks in the documentation
-xsv-0.13.0/src/cmd/stats.rs:536:35: casting `f64` to `i64` may truncate the value
-xsv-0.13.0/src/cmd/stats.rs:544:33: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-xsv-0.13.0/src/cmd/stats.rs:592:22: calling `stats::MinMax::default()` is more clear than this expression
-xsv-0.13.0/src/cmd/stats.rs:593:22: calling `stats::MinMax::default()` is more clear than this expression
-xsv-0.13.0/src/cmd/stats.rs:594:23: calling `stats::MinMax::default()` is more clear than this expression
-xsv-0.13.0/src/cmd/stats.rs:595:21: calling `stats::MinMax::default()` is more clear than this expression
-xsv-0.13.0/src/cmd/stats.rs:71:1: more than 3 bools in a struct
-xsv-0.13.0/src/cmd/stats.rs:86:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/table.rs:10:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/table.rs:50:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/table.rs:54:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/config.rs:113:43: use of `unwrap_or` followed by a function call
-xsv-0.13.0/src/config.rs:197:48: trait objects without an explicit `dyn` are deprecated
-xsv-0.13.0/src/config.rs:202:48: trait objects without an explicit `dyn` are deprecated
-xsv-0.13.0/src/config.rs:263:47: trait objects without an explicit `dyn` are deprecated
-xsv-0.13.0/src/config.rs:293:47: trait objects without an explicit `dyn` are deprecated
-xsv-0.13.0/src/config.rs:58:1: more than 3 bools in a struct
-xsv-0.13.0/src/config.rs:77:28: explicit deref method call
-xsv-0.13.0/src/config.rs:90:13: redundant field names in struct initialization
-xsv-0.13.0/src/index.rs:31:13: redundant field names in struct initialization
-xsv-0.13.0/src/main.rs:164:49: redundant clone
-xsv-0.13.0/src/main.rs:75:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/select.rs:13:1: item name starts with its containing module's name
-xsv-0.13.0/src/select.rs:154:5: this function's return value is unnecessarily wrapped by `Result`
-xsv-0.13.0/src/select.rs:250:33: binding's name is too similar to existing binding
-xsv-0.13.0/src/select.rs:250:43: binding's name is too similar to existing binding
-xsv-0.13.0/src/select.rs:255:39: an inclusive range would be more readable
-xsv-0.13.0/src/select.rs:280:20: length comparison to zero
-xsv-0.13.0/src/select.rs:29:13: redundant field names in struct initialization
-xsv-0.13.0/src/select.rs:360:62: this argument (8 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-xsv-0.13.0/src/select.rs:360:9: this function's return value is unnecessarily wrapped by `Option`
-xsv-0.13.0/src/select.rs:375:9: used sort instead of sort_unstable to sort primitive type `usize`
-xsv-0.13.0/src/select.rs:379:18: it is more concise to loop over containers instead of using explicit iteration methods
-xsv-0.13.0/src/select.rs:416:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-xsv-0.13.0/src/select.rs:419:9: this function's return value is unnecessarily wrapped by `Option`
-xsv-0.13.0/src/select.rs:420:27: consider using `Option<T>` instead of `Option<Option<T>>` or a custom enum if you need to distinguish all 3 cases
-xsv-0.13.0/src/select.rs:99:17: binding's name is too similar to existing binding
-xsv-0.13.0/src/util.rs:150:5: you should put bare URLs between `<`/`>` or make a proper Markdown link
-xsv-0.13.0/src/util.rs:190:48: trait objects without an explicit `dyn` are deprecated
-xsv-0.13.0/src/util.rs:37:33: you are using an explicit closure for copying elements
-xsv-0.13.0/src/util.rs:90:1: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-rayon-1.5.0/src/collections/binary_heap.rs:7:5: usage of wildcard import
-rayon-1.5.0/src/collections/binary_heap.rs:8:5: usage of wildcard import
-rayon-1.5.0/src/collections/btree_map.rs:7:5: usage of wildcard import
-rayon-1.5.0/src/collections/btree_map.rs:8:5: usage of wildcard import
-rayon-1.5.0/src/collections/btree_set.rs:7:5: usage of wildcard import
-rayon-1.5.0/src/collections/btree_set.rs:8:5: usage of wildcard import
-rayon-1.5.0/src/collections/hash_map.rs:10:5: usage of wildcard import
-rayon-1.5.0/src/collections/hash_map.rs:9:5: usage of wildcard import
-rayon-1.5.0/src/collections/hash_set.rs:10:5: usage of wildcard import
-rayon-1.5.0/src/collections/hash_set.rs:9:5: usage of wildcard import
-rayon-1.5.0/src/collections/linked_list.rs:7:5: usage of wildcard import
-rayon-1.5.0/src/collections/linked_list.rs:8:5: usage of wildcard import
-rayon-1.5.0/src/collections/mod.rs:59:32: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
-rayon-1.5.0/src/collections/vec_deque.rs:8:5: usage of wildcard import
-rayon-1.5.0/src/collections/vec_deque.rs:9:5: usage of wildcard import
-rayon-1.5.0/src/compile_fail/cannot_collect_filtermap_data.rs:2:1: needless `fn main` in doctest
-rayon-1.5.0/src/compile_fail/cannot_zip_filtered_data.rs:2:1: needless `fn main` in doctest
-rayon-1.5.0/src/compile_fail/cell_par_iter.rs:2:1: needless `fn main` in doctest
-rayon-1.5.0/src/compile_fail/no_send_par_iter.rs:25:1: needless `fn main` in doctest
-rayon-1.5.0/src/compile_fail/no_send_par_iter.rs:46:1: needless `fn main` in doctest
-rayon-1.5.0/src/compile_fail/no_send_par_iter.rs:4:1: needless `fn main` in doctest
-rayon-1.5.0/src/compile_fail/rc_par_iter.rs:2:1: needless `fn main` in doctest
-rayon-1.5.0/src/iter/chain.rs:103:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/chain.rs:122:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/chain.rs:128:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/chain.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/chain.rs:221:36: you should put `ExactSizeIterator` between ticks in the documentation
-rayon-1.5.0/src/iter/chain.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/chain.rs:51:38: use Option::map_or_else instead of an if let/else
-rayon-1.5.0/src/iter/chain.rs:58:14: `a` is being shadowed
-rayon-1.5.0/src/iter/chain.rs:58:17: `b` is being shadowed
-rayon-1.5.0/src/iter/chain.rs:78:14: `a` is being shadowed
-rayon-1.5.0/src/iter/chain.rs:78:17: `b` is being shadowed
-rayon-1.5.0/src/iter/chain.rs:97:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/chunks.rs:3:5: usage of wildcard import
-rayon-1.5.0/src/iter/chunks.rs:4:5: usage of wildcard import
-rayon-1.5.0/src/iter/chunks.rs:77:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/chunks.rs:83:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/cloned.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/cloned.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/cloned.rs:71:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/cloned.rs:75:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/collect/consumer.rs:141:5: you should put `CollectReducer` between ticks in the documentation
-rayon-1.5.0/src/iter/collect/consumer.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/collect/consumer.rs:28:5: you should put `CollectResult` between ticks in the documentation
-rayon-1.5.0/src/iter/collect/consumer.rs:36:37: generally you want to avoid `&mut &mut _` if possible
-rayon-1.5.0/src/iter/collect/consumer.rs:36:37: generally you want to avoid `&mut &mut _` if possible
-rayon-1.5.0/src/iter/collect/mod.rs:154:9: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-rayon-1.5.0/src/iter/copied.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/copied.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/copied.rs:71:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/copied.rs:75:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/empty.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/empty.rs:24:1: this function could have a `#[must_use]` attribute
-rayon-1.5.0/src/iter/empty.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/enumerate.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/enumerate.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/enumerate.rs:64:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/enumerate.rs:68:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/extend.rs:143:63: I see you're using a LinkedList! Perhaps you meant some other data structure?
-rayon-1.5.0/src/iter/extend.rs:182:57: I see you're using a LinkedList! Perhaps you meant some other data structure?
-rayon-1.5.0/src/iter/extend.rs:218:32: I see you're using a LinkedList! Perhaps you meant some other data structure?
-rayon-1.5.0/src/iter/extend.rs:218:59: I see you're using a LinkedList! Perhaps you meant some other data structure?
-rayon-1.5.0/src/iter/extend.rs:25:42: I see you're using a LinkedList! Perhaps you meant some other data structure?
-rayon-1.5.0/src/iter/extend.rs:287:62: I see you're using a LinkedList! Perhaps you meant some other data structure?
-rayon-1.5.0/src/iter/extend.rs:322:56: I see you're using a LinkedList! Perhaps you meant some other data structure?
-rayon-1.5.0/src/iter/extend.rs:41:27: I see you're using a LinkedList! Perhaps you meant some other data structure?
-rayon-1.5.0/src/iter/extend.rs:47:30: I see you're using a LinkedList! Perhaps you meant some other data structure?
-rayon-1.5.0/src/iter/extend.rs:47:56: I see you're using a LinkedList! Perhaps you meant some other data structure?
-rayon-1.5.0/src/iter/extend.rs:47:74: I see you're using a LinkedList! Perhaps you meant some other data structure?
-rayon-1.5.0/src/iter/extend.rs:53:29: I see you're using a LinkedList! Perhaps you meant some other data structure?
-rayon-1.5.0/src/iter/extend.rs:57:36: I see you're using a LinkedList! Perhaps you meant some other data structure?
-rayon-1.5.0/src/iter/extend.rs:59:61: I see you're using a LinkedList! Perhaps you meant some other data structure?
-rayon-1.5.0/src/iter/filter.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/filter.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/filter_map.rs:123:9: use Option::map_or instead of an if let/else
-rayon-1.5.0/src/iter/filter_map.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/filter_map.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/find.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/find.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/find_first_last/mod.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/find_first_last/mod.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/find_first_last/mod.rs:32:67: you should put `MatchPosition` between ticks in the documentation
-rayon-1.5.0/src/iter/flat_map.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/flat_map.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/flat_map_iter.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/flat_map_iter.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/flatten.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/flatten.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/flatten_iter.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/flatten_iter.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/fold.rs:158:13: binding's name is too similar to existing binding
-rayon-1.5.0/src/iter/fold.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/fold.rs:204:1: item name starts with its containing module's name
-rayon-1.5.0/src/iter/fold.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/for_each.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/for_each.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/inspect.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/inspect.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/inspect.rs:83:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/inspect.rs:88:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/interleave.rs:111:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/interleave.rs:119:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/interleave.rs:195:30: you should put `self.i_len` between ticks in the documentation
-rayon-1.5.0/src/iter/interleave.rs:195:43: you should put `self.j_len` between ticks in the documentation
-rayon-1.5.0/src/iter/interleave.rs:199:23: you should put `self.i_len` between ticks in the documentation
-rayon-1.5.0/src/iter/interleave.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/interleave.rs:200:23: you should put `self.j_len` between ticks in the documentation
-rayon-1.5.0/src/iter/interleave.rs:249:41: you should put `DoubleEndedIterator` between ticks in the documentation
-rayon-1.5.0/src/iter/interleave.rs:250:5: you should put `ExactSizeIterator` between ticks in the documentation
-rayon-1.5.0/src/iter/interleave.rs:263:33: you should put `InterleaveSeq` between ticks in the documentation
-rayon-1.5.0/src/iter/interleave.rs:280:17: wildcard match will miss any future added variants
-rayon-1.5.0/src/iter/interleave.rs:285:17: wildcard match will miss any future added variants
-rayon-1.5.0/src/iter/interleave.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/interleave.rs:313:9: `if` chain can be rewritten with `match`
-rayon-1.5.0/src/iter/interleave.rs:82:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/interleave.rs:90:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/interleave_shortest.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/intersperse.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/intersperse.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/intersperse.rs:90:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/intersperse.rs:96:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/len.rs:12:1: item name ends with its containing module's name
-rayon-1.5.0/src/iter/len.rs:146:1: item name ends with its containing module's name
-rayon-1.5.0/src/iter/len.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/len.rs:200:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/len.rs:205:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/len.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/len.rs:66:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/len.rs:71:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/map.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/map.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/map.rs:84:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/map.rs:89:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/map_with.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/map_with.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/map_with.rs:419:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/map_with.rs:425:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/map_with.rs:90:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/map_with.rs:96:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/mod.rs:1874:24: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-rayon-1.5.0/src/iter/mod.rs:2171:1: trait `IndexedParallelIterator` has a `len` method but no (possibly inherited) `is_empty` method
-rayon-1.5.0/src/iter/mod.rs:2371:26: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-rayon-1.5.0/src/iter/mod.rs:2411:26: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-rayon-1.5.0/src/iter/mod.rs:82:5: usage of wildcard import
-rayon-1.5.0/src/iter/multizip.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/multizip.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/noop.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/once.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/once.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/panic_fuse.rs:102:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/panic_fuse.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/panic_fuse.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/panic_fuse.rs:98:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/par_bridge.rs:136:28: redundant else block
-rayon-1.5.0/src/iter/par_bridge.rs:163:28: redundant else block
-rayon-1.5.0/src/iter/plumbing/mod.rs:216:58: you should put `find_first` between ticks in the documentation
-rayon-1.5.0/src/iter/plumbing/mod.rs:359:5: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/plumbing/mod.rs:364:5: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/plumbing/mod.rs:399:5: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/plumbing/mod.rs:53:19: you should put `DoubleEndedIterator` between ticks in the documentation
-rayon-1.5.0/src/iter/plumbing/mod.rs:53:43: you should put `ExactSizeIterator` between ticks in the documentation
-rayon-1.5.0/src/iter/plumbing/mod.rs:54:31: you should put `IntoIterator` between ticks in the documentation
-rayon-1.5.0/src/iter/plumbing/mod.rs:55:5: you should put `IntoIterator` between ticks in the documentation
-rayon-1.5.0/src/iter/positions.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/positions.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/product.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/reduce.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/repeat.rs:103:1: item name starts with its containing module's name
-rayon-1.5.0/src/iter/repeat.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/repeat.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/rev.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/rev.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/rev.rs:63:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/rev.rs:68:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/skip.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/skip.rs:3:5: usage of wildcard import
-rayon-1.5.0/src/iter/skip.rs:68:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/skip.rs:73:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/splitter.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/splitter.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/step_by.rs:4:5: usage of wildcard import
-rayon-1.5.0/src/iter/step_by.rs:5:5: usage of wildcard import
-rayon-1.5.0/src/iter/step_by.rs:73:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/step_by.rs:79:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/sum.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/take.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/take.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/take.rs:67:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/take.rs:72:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/try_fold.rs:190:1: item name starts with its containing module's name
-rayon-1.5.0/src/iter/try_fold.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/try_fold.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/try_reduce.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/try_reduce_with.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/unzip.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/unzip.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/update.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/update.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/update.rs:82:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/update.rs:87:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/while_some.rs:130:22: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-rayon-1.5.0/src/iter/while_some.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/while_some.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/zip.rs:102:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/zip.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/zip.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/zip.rs:74:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/zip.rs:79:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/zip.rs:97:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/zip_eq.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/zip_eq.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/option.rs:8:5: usage of wildcard import
-rayon-1.5.0/src/option.rs:9:5: usage of wildcard import
-rayon-1.5.0/src/par_either.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/par_either.rs:3:5: usage of wildcard import
-rayon-1.5.0/src/private.rs:9:1: item name starts with its containing module's name
-rayon-1.5.0/src/range.rs:19:5: usage of wildcard import
-rayon-1.5.0/src/range.rs:20:5: usage of wildcard import
-rayon-1.5.0/src/range_inclusive.rs:194:9: an inclusive range would be more readable
-rayon-1.5.0/src/range_inclusive.rs:194:9: an inclusive range would be more readable
-rayon-1.5.0/src/range_inclusive.rs:19:5: usage of wildcard import
-rayon-1.5.0/src/range_inclusive.rs:209:9: an inclusive range would be more readable
-rayon-1.5.0/src/range_inclusive.rs:209:9: an inclusive range would be more readable
-rayon-1.5.0/src/range_inclusive.rs:20:5: usage of wildcard import
-rayon-1.5.0/src/range_inclusive.rs:231:9: an inclusive range would be more readable
-rayon-1.5.0/src/range_inclusive.rs:231:9: an inclusive range would be more readable
-rayon-1.5.0/src/result.rs:8:5: usage of wildcard import
-rayon-1.5.0/src/result.rs:9:5: usage of wildcard import
-rayon-1.5.0/src/slice/mergesort.rs:102:5: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/slice/mergesort.rs:109:5: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/slice/mergesort.rs:114:5: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/slice/mergesort.rs:211:5: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/slice/mergesort.rs:217:5: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/slice/mergesort.rs:251:5: you should put `TimSort` between ticks in the documentation
-rayon-1.5.0/src/slice/mergesort.rs:252:5: you should put bare URLs between `<`/`>` or make a proper Markdown link
-rayon-1.5.0/src/slice/mergesort.rs:286:59: you should put `TimSort` between ticks in the documentation
-rayon-1.5.0/src/slice/mergesort.rs:333:24: redundant else block
-rayon-1.5.0/src/slice/mergesort.rs:513:5: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/slice/mergesort.rs:521:5: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/slice/mergesort.rs:7:5: usage of wildcard import
-rayon-1.5.0/src/slice/mergesort.rs:98:5: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/slice/mod.rs:15:5: usage of wildcard import
-rayon-1.5.0/src/slice/mod.rs:16:5: usage of wildcard import
-rayon-1.5.0/src/slice/mod.rs:17:5: usage of wildcard import
-rayon-1.5.0/src/slice/mod.rs:25:1: item name ends with its containing module's name
-rayon-1.5.0/src/slice/mod.rs:657:5: this method could have a `#[must_use]` attribute
-rayon-1.5.0/src/slice/mod.rs:971:5: this method could have a `#[must_use]` attribute
-rayon-1.5.0/src/slice/quicksort.rs:230:36: you should put `BlockQuicksort` between ticks in the documentation
-rayon-1.5.0/src/slice/quicksort.rs:233:1: this function has too many lines (117/100)
-rayon-1.5.0/src/slice/quicksort.rs:258:26: integer type suffix should be separated by an underscore
-rayon-1.5.0/src/slice/quicksort.rs:265:26: integer type suffix should be separated by an underscore
-rayon-1.5.0/src/slice/quicksort.rs:268:5: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/slice/quicksort.rs:308:30: casting `usize` to `u8` may truncate the value
-rayon-1.5.0/src/slice/quicksort.rs:325:30: casting `usize` to `u8` may truncate the value
-rayon-1.5.0/src/slice/quicksort.rs:393:36: casting `u8` to `isize` may wrap around the value on targets with 32-bit wide pointers
-rayon-1.5.0/src/slice/quicksort.rs:405:40: casting `u8` to `isize` may wrap around the value on targets with 32-bit wide pointers
-rayon-1.5.0/src/slice/quicksort.rs:430:14: `pivot` is being shadowed
-rayon-1.5.0/src/slice/quicksort.rs:439:13: `pivot` is being shadowed
-rayon-1.5.0/src/slice/quicksort.rs:482:10: `pivot` is being shadowed
-rayon-1.5.0/src/slice/quicksort.rs:491:9: `pivot` is being shadowed
-rayon-1.5.0/src/slice/quicksort.rs:534:26: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-rayon-1.5.0/src/slice/quicksort.rs:545:17: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
-rayon-1.5.0/src/slice/quicksort.rs:588:17: the operation is ineffective. Consider reducing it to `len / 4`
-rayon-1.5.0/src/slice/quicksort.rs:716:14: `pivot` is being shadowed
-rayon-1.5.0/src/split_producer.rs:56:16: use Option::map_or_else instead of an if let/else
-rayon-1.5.0/src/split_producer.rs:92:9: use Option::map_or instead of an if let/else
-rayon-1.5.0/src/str.rs:16:5: usage of wildcard import
-rayon-1.5.0/src/str.rs:17:5: usage of wildcard import
-rayon-1.5.0/src/str.rs:18:5: usage of wildcard import
-rayon-1.5.0/src/str.rs:25:5: casting `u8` to `i8` may wrap around the value
-rayon-1.5.0/src/str.rs:715:9: stripping a suffix manually
-rayon-1.5.0/src/string.rs:5:5: usage of wildcard import
-rayon-1.5.0/src/vec.rs:137:12: length comparison to zero
-rayon-1.5.0/src/vec.rs:8:5: usage of wildcard import
-rayon-1.5.0/src/vec.rs:9:5: usage of wildcard import
-rand-0.7.3/src/distributions/bernoulli.rs:103:20: casting `f64` to `u64` may lose the sign of the value
-rand-0.7.3/src/distributions/bernoulli.rs:103:20: casting `f64` to `u64` may truncate the value
-rand-0.7.3/src/distributions/bernoulli.rs:116:5: docs for function returning `Result` missing `# Errors` section
-rand-0.7.3/src/distributions/bernoulli.rs:123:21: casting `f64` to `u64` may lose the sign of the value
-rand-0.7.3/src/distributions/bernoulli.rs:123:21: casting `f64` to `u64` may truncate the value
-rand-0.7.3/src/distributions/bernoulli.rs:63:26: casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/bernoulli.rs:63:27: integer type suffix should be separated by an underscore
-rand-0.7.3/src/distributions/bernoulli.rs:67:1: item name starts with its containing module's name
-rand-0.7.3/src/distributions/bernoulli.rs:95:5: docs for function returning `Result` missing `# Errors` section
-rand-0.7.3/src/distributions/bernoulli.rs:96:13: manual `Range::contains` implementation
-rand-0.7.3/src/distributions/binomial.rs:107:23: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/binomial.rs:112:44: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/binomial.rs:116:13: adding items after statements is confusing, since items exist from the start of the scope
-rand-0.7.3/src/distributions/binomial.rs:150:28: redundant else block
-rand-0.7.3/src/distributions/binomial.rs:153:24: unnecessary boolean `not` operation
-rand-0.7.3/src/distributions/binomial.rs:158:28: redundant else block
-rand-0.7.3/src/distributions/binomial.rs:164:33: casting `i64` to `u64` may lose the sign of the value
-rand-0.7.3/src/distributions/binomial.rs:166:28: redundant else block
-rand-0.7.3/src/distributions/binomial.rs:175:47: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/binomial.rs:185:38: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/binomial.rs:194:38: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/binomial.rs:202:28: redundant else block
-rand-0.7.3/src/distributions/binomial.rs:209:25: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/binomial.rs:221:26: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/binomial.rs:222:26: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/binomial.rs:223:25: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/binomial.rs:224:25: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/binomial.rs:226:17: adding items after statements is confusing, since items exist from the start of the scope
-rand-0.7.3/src/distributions/binomial.rs:233:32: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/binomial.rs:234:27: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/binomial.rs:251:22: casting `i64` to `u64` may lose the sign of the value
-rand-0.7.3/src/distributions/binomial.rs:255:9: unnecessary `!=` operation
-rand-0.7.3/src/distributions/binomial.rs:35:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/distributions/binomial.rs:45:17: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/binomial.rs:46:5: casting `f64` to `i64` may truncate the value
-rand-0.7.3/src/distributions/binomial.rs:50:5: this function has too many lines (143/100)
-rand-0.7.3/src/distributions/binomial.rs:76:9: adding items after statements is confusing, since items exist from the start of the scope
-rand-0.7.3/src/distributions/binomial.rs:78:12: casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/binomial.rs:81:21: casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/binomial.rs:82:32: casting `u64` to `i32` may truncate the value
-rand-0.7.3/src/distributions/binomial.rs:88:26: casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/binomial.rs:99:21: casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/cauchy.rs:33:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/distributions/dirichlet.rs:52:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/distributions/dirichlet.rs:64:32: float type suffix should be separated by an underscore
-rand-0.7.3/src/distributions/dirichlet.rs:65:23: float type suffix should be separated by an underscore
-rand-0.7.3/src/distributions/exponential.rs:76:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/distributions/float.rs:73:1: item name ends with its containing module's name
-rand-0.7.3/src/distributions/gamma.rs:13:5: usage of wildcard import for enum variants
-rand-0.7.3/src/distributions/gamma.rs:14:5: usage of wildcard import for enum variants
-rand-0.7.3/src/distributions/gamma.rs:189:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/distributions/gamma.rs:230:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/distributions/gamma.rs:259:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/distributions/gamma.rs:287:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/distributions/gamma.rs:90:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/distributions/integer.rs:23:9: casting `u32` to `u8` may truncate the value
-rand-0.7.3/src/distributions/integer.rs:30:9: casting `u32` to `u16` may truncate the value
-rand-0.7.3/src/distributions/integer.rs:69:9: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
-rand-0.7.3/src/distributions/mod.rs:263:5: you have declared `#[inline(always)]` on `next`. This is usually a bad idea
-rand-0.7.3/src/distributions/normal.rs:100:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/distributions/normal.rs:119:1: item name ends with its containing module's name
-rand-0.7.3/src/distributions/normal.rs:131:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/distributions/normal.rs:31:1: item name ends with its containing module's name
-rand-0.7.3/src/distributions/normal.rs:47:25: float type suffix should be separated by an underscore
-rand-0.7.3/src/distributions/normal.rs:48:25: float type suffix should be separated by an underscore
-rand-0.7.3/src/distributions/other.rs:89:9: casting `u32` to `i32` may wrap around the value
-rand-0.7.3/src/distributions/pareto.rs:32:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/distributions/poisson.rs:35:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/distributions/poisson.rs:87:30: casting `f64` to `u64` may lose the sign of the value
-rand-0.7.3/src/distributions/poisson.rs:87:30: casting `f64` to `u64` may truncate the value
-rand-0.7.3/src/distributions/triangular.rs:32:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/distributions/uniform.rs:146:4: needless `fn main` in doctest
-rand-0.7.3/src/distributions/uniform.rs:199:1: item name ends with its containing module's name
-rand-0.7.3/src/distributions/uniform.rs:214:1: item name starts with its containing module's name
-rand-0.7.3/src/distributions/uniform.rs:283:14: you should put `SampleUniform` between ticks in the documentation
-rand-0.7.3/src/distributions/uniform.rs:283:46: you should put `SampleUniform` between ticks in the documentation
-rand-0.7.3/src/distributions/uniform.rs:296:5: you have declared `#[inline(always)]` on `borrow`. This is usually a bad idea
-rand-0.7.3/src/distributions/uniform.rs:304:5: you have declared `#[inline(always)]` on `borrow`. This is usually a bad idea
-rand-0.7.3/src/distributions/uniform.rs:350:1: item name starts with its containing module's name
-rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
-rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
-rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
-rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
-rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
-rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
-rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
-rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
-rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
-rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
-rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
-rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
-rand-0.7.3/src/distributions/uniform.rs:441:31: because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false
-rand-0.7.3/src/distributions/uniform.rs:441:31: because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false
-rand-0.7.3/src/distributions/uniform.rs:441:31: because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false
-rand-0.7.3/src/distributions/uniform.rs:441:31: because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false
-rand-0.7.3/src/distributions/uniform.rs:441:31: because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false
-rand-0.7.3/src/distributions/uniform.rs:441:31: because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false
-rand-0.7.3/src/distributions/uniform.rs:441:31: because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false
-rand-0.7.3/src/distributions/uniform.rs:441:31: because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false
-rand-0.7.3/src/distributions/uniform.rs:56:10: you should put `SampleBorrow` between ticks in the documentation
-rand-0.7.3/src/distributions/uniform.rs:647:1: item name starts with its containing module's name
-rand-0.7.3/src/distributions/uniform.rs:840:1: item name starts with its containing module's name
-rand-0.7.3/src/distributions/uniform.rs:913:13: use Option::map_or_else instead of an if let/else
-rand-0.7.3/src/distributions/uniform.rs:943:54: casting `u64` to `u32` may truncate the value
-rand-0.7.3/src/distributions/unit_circle.rs:30:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/distributions/unit_sphere.rs:24:1: item name starts with its containing module's name
-rand-0.7.3/src/distributions/unit_sphere.rs:29:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/distributions/utils.rs:254:5: you have declared `#[inline(always)]` on `lanes`. This is usually a bad idea
-rand-0.7.3/src/distributions/utils.rs:258:5: you have declared `#[inline(always)]` on `splat`. This is usually a bad idea
-rand-0.7.3/src/distributions/utils.rs:262:5: you have declared `#[inline(always)]` on `extract`. This is usually a bad idea
-rand-0.7.3/src/distributions/utils.rs:267:5: you have declared `#[inline(always)]` on `replace`. This is usually a bad idea
-rand-0.7.3/src/distributions/utils.rs:281:5: you have declared `#[inline(always)]` on `any`. This is usually a bad idea
-rand-0.7.3/src/distributions/utils.rs:286:5: you have declared `#[inline(always)]` on `all`. This is usually a bad idea
-rand-0.7.3/src/distributions/utils.rs:291:5: you have declared `#[inline(always)]` on `none`. This is usually a bad idea
-rand-0.7.3/src/distributions/utils.rs:488:17: you should put `x_i` between ticks in the documentation
-rand-0.7.3/src/distributions/utils.rs:489:50: you should put `x_i` between ticks in the documentation
-rand-0.7.3/src/distributions/utils.rs:489:63: you should put `f(x_i` between ticks in the documentation
-rand-0.7.3/src/distributions/utils.rs:490:40: you should put `f(x_i` between ticks in the documentation
-rand-0.7.3/src/distributions/utils.rs:490:49: you should put `f(x_{i+1` between ticks in the documentation
-rand-0.7.3/src/distributions/utils.rs:518:17: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
-rand-0.7.3/src/distributions/weibull.rs:29:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/distributions/weighted/alias_method.rs:113:21: it is more concise to loop over references to containers instead of using explicit iteration methods
-rand-0.7.3/src/distributions/weighted/alias_method.rs:125:9: adding items after statements is confusing, since items exist from the start of the scope
-rand-0.7.3/src/distributions/weighted/alias_method.rs:131:9: adding items after statements is confusing, since items exist from the start of the scope
-rand-0.7.3/src/distributions/weighted/alias_method.rs:180:36: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-rand-0.7.3/src/distributions/weighted/alias_method.rs:182:34: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-rand-0.7.3/src/distributions/weighted/alias_method.rs:259:28: using `clone` on type `distributions::uniform::Uniform<u32>` which implements the `Copy` trait
-rand-0.7.3/src/distributions/weighted/alias_method.rs:296:9: you are using an explicit closure for copying elements
-rand-0.7.3/src/distributions/weighted/alias_method.rs:321:9: you are using an explicit closure for copying elements
-rand-0.7.3/src/distributions/weighted/alias_method.rs:78:5: docs for function returning `Result` missing `# Errors` section
-rand-0.7.3/src/distributions/weighted/alias_method.rs:78:5: this function has too many lines (106/100)
-rand-0.7.3/src/distributions/weighted/alias_method.rs:85:17: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-rand-0.7.3/src/distributions/weighted/alias_method.rs:87:31: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
-rand-0.7.3/src/distributions/weighted/mod.rs:100:5: docs for function returning `Result` missing `# Errors` section
-rand-0.7.3/src/distributions/weighted/mod.rs:144:5: docs for function returning `Result` missing `# Errors` section
-rand-0.7.3/src/distributions/weighted/mod.rs:169:16: unnecessary `>= y + 1` or `x - 1 >=`
-rand-0.7.3/src/distributions/weighted/mod.rs:386:1: item name starts with its containing module's name
-rand-0.7.3/src/distributions/weighted/mod.rs:85:1: item name starts with its containing module's name
-rand-0.7.3/src/lib.rs:333:5: docs for function returning `Result` missing `# Errors` section
-rand-0.7.3/src/lib.rs:552:1: this function could have a `#[must_use]` attribute
-rand-0.7.3/src/rngs/adapter/read.rs:47:1: item name starts with its containing module's name
-rand-0.7.3/src/rngs/adapter/read.rs:89:1: item name starts with its containing module's name
-rand-0.7.3/src/rngs/adapter/reseeding.rs:100:5: docs for function returning `Result` missing `# Errors` section
-rand-0.7.3/src/rngs/adapter/reseeding.rs:112:5: you have declared `#[inline(always)]` on `next_u32`. This is usually a bad idea
-rand-0.7.3/src/rngs/adapter/reseeding.rs:117:5: you have declared `#[inline(always)]` on `next_u64`. This is usually a bad idea
-rand-0.7.3/src/rngs/adapter/reseeding.rs:198:13: casting `u64` to `i64` may wrap around the value
-rand-0.7.3/src/rngs/adapter/reseeding.rs:231:9: casting `usize` to `isize` may wrap around the value
-rand-0.7.3/src/rngs/adapter/reseeding.rs:27:28: you should put `ChaCha` between ticks in the documentation
-rand-0.7.3/src/rngs/adapter/reseeding.rs:79:1: item name starts with its containing module's name
-rand-0.7.3/src/rngs/entropy.rs:24:1: item name starts with its containing module's name
-rand-0.7.3/src/rngs/entropy.rs:34:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/rngs/mock.rs:36:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/rngs/mock.rs:47:9: casting `u64` to `u32` may truncate the value
-rand-0.7.3/src/rngs/mod.rs:61:74: you should put `ChaCha20` between ticks in the documentation
-rand-0.7.3/src/rngs/std.rs:25:39: you should put `ChaCha` between ticks in the documentation
-rand-0.7.3/src/rngs/std.rs:32:10: you should put `rand_chacha` between ticks in the documentation
-rand-0.7.3/src/rngs/std.rs:36:1: item name starts with its containing module's name
-rand-0.7.3/src/rngs/std.rs:39:5: you have declared `#[inline(always)]` on `next_u32`. This is usually a bad idea
-rand-0.7.3/src/rngs/std.rs:44:5: you have declared `#[inline(always)]` on `next_u64`. This is usually a bad idea
-rand-0.7.3/src/rngs/std.rs:49:5: you have declared `#[inline(always)]` on `fill_bytes`. This is usually a bad idea
-rand-0.7.3/src/rngs/std.rs:54:5: you have declared `#[inline(always)]` on `try_fill_bytes`. This is usually a bad idea
-rand-0.7.3/src/rngs/std.rs:63:5: you have declared `#[inline(always)]` on `from_seed`. This is usually a bad idea
-rand-0.7.3/src/rngs/std.rs:68:5: you have declared `#[inline(always)]` on `from_rng`. This is usually a bad idea
-rand-0.7.3/src/rngs/thread.rs:57:1: item name starts with its containing module's name
-rand-0.7.3/src/rngs/thread.rs:80:1: item name starts with its containing module's name
-rand-0.7.3/src/rngs/thread.rs:80:1: this function could have a `#[must_use]` attribute
-rand-0.7.3/src/rngs/thread.rs:81:35: redundant closure found
-rand-0.7.3/src/rngs/thread.rs:93:5: you have declared `#[inline(always)]` on `next_u32`. This is usually a bad idea
-rand-0.7.3/src/rngs/thread.rs:98:5: you have declared `#[inline(always)]` on `next_u64`. This is usually a bad idea
-rand-0.7.3/src/seq/index.rs:127:1: item name starts with its containing module's name
-rand-0.7.3/src/seq/index.rs:139:13: usage of wildcard import for enum variants
-rand-0.7.3/src/seq/index.rs:159:1: item name starts with its containing module's name
-rand-0.7.3/src/seq/index.rs:171:13: usage of wildcard import for enum variants
-rand-0.7.3/src/seq/index.rs:180:13: usage of wildcard import for enum variants
-rand-0.7.3/src/seq/index.rs:223:18: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-rand-0.7.3/src/seq/index.rs:224:18: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-rand-0.7.3/src/seq/index.rs:233:25: casting `u32` to `f32` causes a loss of precision (`u32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)
-rand-0.7.3/src/seq/index.rs:236:27: casting `u32` to `f32` causes a loss of precision (`u32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)
-rand-0.7.3/src/seq/index.rs:244:12: casting `u32` to `f32` causes a loss of precision (`u32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)
-rand-0.7.3/src/seq/index.rs:244:37: casting `u32` to `f32` causes a loss of precision (`u32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)
-rand-0.7.3/src/seq/index.rs:29:1: item name starts with its containing module's name
-rand-0.7.3/src/seq/index.rs:39:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/seq/index.rs:48:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/seq/index.rs:60:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/seq/index.rs:69:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/seq/index.rs:78:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/seq/index.rs:87:5: method `into_iter` can be confused for the standard trait method `std::iter::IntoIterator::into_iter`
-rand-0.7.3/src/seq/index.rs:87:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/seq/index.rs:97:13: usage of wildcard import for enum variants
-rand-0.7.3/src/seq/mod.rs:141:5: docs for function returning `Result` missing `# Errors` section
-rand-0.7.3/src/seq/mod.rs:168:5: docs for function returning `Result` missing `# Errors` section
-rand-0.7.3/src/seq/mod.rs:229:4: needless `fn main` in doctest
-rand-0.7.3/src/seq/mod.rs:292:29: casting `usize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`usize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/seq/mod.rs:410:23: calling `std::marker::PhantomData::default()` is more clear than this expression
-rand-0.7.3/src/seq/mod.rs:45:4: needless `fn main` in doctest
-rand-0.7.3/src/seq/mod.rs:527:26: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-syn-1.0.54/src/lit.rs:1397:40: redundant else block
-syn-1.0.54/src/lit.rs:1405:28: redundant else block
-syn-1.0.54/src/lit.rs:1485:32: redundant else block
 libc-0.2.81/build.rs:114:19: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
 libc-0.2.81/build.rs:124:5: this block may be rewritten with the `?` operator
 libc-0.2.81/build.rs:133:5: this block may be rewritten with the `?` operator
@@ -2658,6 +1910,109 @@ libc-0.2.81/src/unix/mod.rs:285:36: long literal lacking separators
 libc-0.2.81/src/unix/mod.rs:34:1: enum with no variants
 libc-0.2.81/src/unix/mod.rs:386:1: enum with no variants
 libc-0.2.81/src/unix/mod.rs:394:1: enum with no variants
+log-0.4.11/src/lib.rs:1047:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:1053:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:1059:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:1093:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:1093:5: you should consider adding a `Default` implementation for `MetadataBuilder<'a>`
+log-0.4.11/src/lib.rs:1118:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:1177:1: you have declared `#[inline(always)]` on `max_level`. This is usually a bad idea
+log-0.4.11/src/lib.rs:1178:1: this function could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:1306:1: docs for function returning `Result` missing `# Errors` section
+log-0.4.11/src/lib.rs:1358:1: this function could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:1359:5: unnecessary `!=` operation
+log-0.4.11/src/lib.rs:1407:1: this function could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:329:27: you are deriving `Hash` but have implemented `PartialEq` explicitly
+log-0.4.11/src/lib.rs:356:1: you are implementing `Clone` explicitly on a `Copy` type
+log-0.4.11/src/lib.rs:448:12: manual `RangeInclusive::contains` implementation
+log-0.4.11/src/lib.rs:468:13: called `filter(..).map(..)` on an `Iterator`
+log-0.4.11/src/lib.rs:500:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:506:28: this argument (8 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+log-0.4.11/src/lib.rs:506:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:520:27: you are deriving `Hash` but have implemented `PartialEq` explicitly
+log-0.4.11/src/lib.rs:538:1: you are implementing `Clone` explicitly on a `Copy` type
+log-0.4.11/src/lib.rs:653:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:661:21: this argument (8 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+log-0.4.11/src/lib.rs:661:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:677:44: this `match` has identical arm bodies
+log-0.4.11/src/lib.rs:758:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:764:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:770:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:776:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:782:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:788:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:794:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:803:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:809:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:818:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:908:5: this method could have a `#[must_use]` attribute
+log-0.4.11/src/lib.rs:908:5: you should consider adding a `Default` implementation for `RecordBuilder<'a>`
+log-0.4.11/src/lib.rs:995:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/detection.rs:2:5: usage of wildcard import
+proc-macro2-1.0.24/src/fallback.rs:108:17: wildcard match will miss any future added variants
+proc-macro2-1.0.24/src/fallback.rs:269:20: unused `self` argument
+proc-macro2-1.0.24/src/fallback.rs:430:24: this argument (0 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+proc-macro2-1.0.24/src/fallback.rs:437:23: this argument (0 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+proc-macro2-1.0.24/src/fallback.rs:437:23: unused `self` argument
+proc-macro2-1.0.24/src/fallback.rs:471:17: this argument (0 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+proc-macro2-1.0.24/src/fallback.rs:471:17: unused `self` argument
+proc-macro2-1.0.24/src/fallback.rs:654:5: manual `RangeInclusive::contains` implementation
+proc-macro2-1.0.24/src/fallback.rs:655:12: manual `RangeInclusive::contains` implementation
+proc-macro2-1.0.24/src/fallback.rs:661:5: manual `RangeInclusive::contains` implementation
+proc-macro2-1.0.24/src/fallback.rs:662:12: manual `RangeInclusive::contains` implementation
+proc-macro2-1.0.24/src/fallback.rs:664:12: manual `RangeInclusive::contains` implementation
+proc-macro2-1.0.24/src/fallback.rs:674:37: manual `RangeInclusive::contains` implementation
+proc-macro2-1.0.24/src/fallback.rs:678:5: adding items after statements is confusing, since items exist from the start of the scope
+proc-macro2-1.0.24/src/fallback.rs:85:9: adding items after statements is confusing, since items exist from the start of the scope
+proc-macro2-1.0.24/src/fallback.rs:882:43: unused `self` argument
+proc-macro2-1.0.24/src/lib.rs:1017:9: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:1081:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:1099:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:1117:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:1135:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:1141:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:1146:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:1151:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:1156:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:152:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:157:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:373:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:383:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:397:24: this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+proc-macro2-1.0.24/src/lib.rs:397:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:403:23: this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+proc-macro2-1.0.24/src/lib.rs:403:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:418:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:425:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:464:17: this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+proc-macro2-1.0.24/src/lib.rs:500:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:626:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:633:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:641:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:652:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:662:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:672:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:734:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:743:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:752:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:757:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:788:19: you should put `XID_Start` between ticks in the documentation
+proc-macro2-1.0.24/src/lib.rs:788:69: you should put `XID_Continue` between ticks in the documentation
+proc-macro2-1.0.24/src/lib.rs:891:36: you should put `syn::parse_str` between ticks in the documentation
+proc-macro2-1.0.24/src/lib.rs:894:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:911:5: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/lib.rs:996:9: this method could have a `#[must_use]` attribute
+proc-macro2-1.0.24/src/parse.rs:552:5: this loop could be written as a `for` loop
+proc-macro2-1.0.24/src/parse.rs:584:21: manual `RangeInclusive::contains` implementation
+proc-macro2-1.0.24/src/parse.rs:602:20: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
+proc-macro2-1.0.24/src/parse.rs:696:29: casting `u8` to `u64` may become silently lossy if you later change the type
+proc-macro2-1.0.24/src/parse.rs:702:34: casting `u8` to `u64` may become silently lossy if you later change the type
+proc-macro2-1.0.24/src/parse.rs:708:34: casting `u8` to `u64` may become silently lossy if you later change the type
+proc-macro2-1.0.24/src/parse.rs:803:15: it is more concise to loop over references to containers instead of using explicit iteration methods
+proc-macro2-1.0.24/src/parse.rs:808:15: it is more concise to loop over references to containers instead of using explicit iteration methods
+proc-macro2-1.0.24/src/wrapper.rs:415:24: this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+proc-macro2-1.0.24/src/wrapper.rs:429:23: this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+proc-macro2-1.0.24/src/wrapper.rs:492:17: this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
 quote-1.0.7/src/ext.rs:10:1: item name ends with its containing module's name
 quote-1.0.7/src/ext.rs:7:5: you should put `TokenStream` between ticks in the documentation
 quote-1.0.7/src/ident_fragment.rs:13:5: docs for function returning `Result` missing `# Errors` section
@@ -2666,6 +2021,206 @@ quote-1.0.7/src/runtime.rs:52:5: item name ends with its containing module's nam
 quote-1.0.7/src/runtime.rs:63:5: item name ends with its containing module's name
 quote-1.0.7/src/runtime.rs:66:33: you should put `DoesNotHaveIter` between ticks in the documentation
 quote-1.0.7/src/runtime.rs:80:5: item name ends with its containing module's name
+rand-0.7.3/src/distributions/bernoulli.rs:103:20: casting `f64` to `u64` may lose the sign of the value
+rand-0.7.3/src/distributions/bernoulli.rs:103:20: casting `f64` to `u64` may truncate the value
+rand-0.7.3/src/distributions/bernoulli.rs:116:5: docs for function returning `Result` missing `# Errors` section
+rand-0.7.3/src/distributions/bernoulli.rs:123:21: casting `f64` to `u64` may lose the sign of the value
+rand-0.7.3/src/distributions/bernoulli.rs:123:21: casting `f64` to `u64` may truncate the value
+rand-0.7.3/src/distributions/bernoulli.rs:63:26: casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/bernoulli.rs:63:27: integer type suffix should be separated by an underscore
+rand-0.7.3/src/distributions/bernoulli.rs:67:1: item name starts with its containing module's name
+rand-0.7.3/src/distributions/bernoulli.rs:95:5: docs for function returning `Result` missing `# Errors` section
+rand-0.7.3/src/distributions/bernoulli.rs:96:13: manual `Range::contains` implementation
+rand-0.7.3/src/distributions/binomial.rs:107:23: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/binomial.rs:112:44: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/binomial.rs:116:13: adding items after statements is confusing, since items exist from the start of the scope
+rand-0.7.3/src/distributions/binomial.rs:150:28: redundant else block
+rand-0.7.3/src/distributions/binomial.rs:153:24: unnecessary boolean `not` operation
+rand-0.7.3/src/distributions/binomial.rs:158:28: redundant else block
+rand-0.7.3/src/distributions/binomial.rs:164:33: casting `i64` to `u64` may lose the sign of the value
+rand-0.7.3/src/distributions/binomial.rs:166:28: redundant else block
+rand-0.7.3/src/distributions/binomial.rs:175:47: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/binomial.rs:185:38: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/binomial.rs:194:38: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/binomial.rs:202:28: redundant else block
+rand-0.7.3/src/distributions/binomial.rs:209:25: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/binomial.rs:221:26: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/binomial.rs:222:26: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/binomial.rs:223:25: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/binomial.rs:224:25: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/binomial.rs:226:17: adding items after statements is confusing, since items exist from the start of the scope
+rand-0.7.3/src/distributions/binomial.rs:233:32: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/binomial.rs:234:27: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/binomial.rs:251:22: casting `i64` to `u64` may lose the sign of the value
+rand-0.7.3/src/distributions/binomial.rs:255:9: unnecessary `!=` operation
+rand-0.7.3/src/distributions/binomial.rs:35:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/distributions/binomial.rs:45:17: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/binomial.rs:46:5: casting `f64` to `i64` may truncate the value
+rand-0.7.3/src/distributions/binomial.rs:50:5: this function has too many lines (143/100)
+rand-0.7.3/src/distributions/binomial.rs:76:9: adding items after statements is confusing, since items exist from the start of the scope
+rand-0.7.3/src/distributions/binomial.rs:78:12: casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/binomial.rs:81:21: casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/binomial.rs:82:32: casting `u64` to `i32` may truncate the value
+rand-0.7.3/src/distributions/binomial.rs:88:26: casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/binomial.rs:99:21: casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/distributions/cauchy.rs:33:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/distributions/dirichlet.rs:52:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/distributions/dirichlet.rs:64:32: float type suffix should be separated by an underscore
+rand-0.7.3/src/distributions/dirichlet.rs:65:23: float type suffix should be separated by an underscore
+rand-0.7.3/src/distributions/exponential.rs:76:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/distributions/float.rs:73:1: item name ends with its containing module's name
+rand-0.7.3/src/distributions/gamma.rs:13:5: usage of wildcard import for enum variants
+rand-0.7.3/src/distributions/gamma.rs:14:5: usage of wildcard import for enum variants
+rand-0.7.3/src/distributions/gamma.rs:189:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/distributions/gamma.rs:230:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/distributions/gamma.rs:259:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/distributions/gamma.rs:287:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/distributions/gamma.rs:90:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/distributions/integer.rs:23:9: casting `u32` to `u8` may truncate the value
+rand-0.7.3/src/distributions/integer.rs:30:9: casting `u32` to `u16` may truncate the value
+rand-0.7.3/src/distributions/integer.rs:69:9: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
+rand-0.7.3/src/distributions/mod.rs:263:5: you have declared `#[inline(always)]` on `next`. This is usually a bad idea
+rand-0.7.3/src/distributions/normal.rs:100:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/distributions/normal.rs:119:1: item name ends with its containing module's name
+rand-0.7.3/src/distributions/normal.rs:131:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/distributions/normal.rs:31:1: item name ends with its containing module's name
+rand-0.7.3/src/distributions/normal.rs:47:25: float type suffix should be separated by an underscore
+rand-0.7.3/src/distributions/normal.rs:48:25: float type suffix should be separated by an underscore
+rand-0.7.3/src/distributions/other.rs:89:9: casting `u32` to `i32` may wrap around the value
+rand-0.7.3/src/distributions/pareto.rs:32:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/distributions/poisson.rs:35:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/distributions/poisson.rs:87:30: casting `f64` to `u64` may lose the sign of the value
+rand-0.7.3/src/distributions/poisson.rs:87:30: casting `f64` to `u64` may truncate the value
+rand-0.7.3/src/distributions/triangular.rs:32:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/distributions/uniform.rs:146:4: needless `fn main` in doctest
+rand-0.7.3/src/distributions/uniform.rs:199:1: item name ends with its containing module's name
+rand-0.7.3/src/distributions/uniform.rs:214:1: item name starts with its containing module's name
+rand-0.7.3/src/distributions/uniform.rs:283:14: you should put `SampleUniform` between ticks in the documentation
+rand-0.7.3/src/distributions/uniform.rs:283:46: you should put `SampleUniform` between ticks in the documentation
+rand-0.7.3/src/distributions/uniform.rs:296:5: you have declared `#[inline(always)]` on `borrow`. This is usually a bad idea
+rand-0.7.3/src/distributions/uniform.rs:304:5: you have declared `#[inline(always)]` on `borrow`. This is usually a bad idea
+rand-0.7.3/src/distributions/uniform.rs:350:1: item name starts with its containing module's name
+rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
+rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
+rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
+rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
+rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
+rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
+rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
+rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
+rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
+rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
+rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
+rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
+rand-0.7.3/src/distributions/uniform.rs:441:31: because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false
+rand-0.7.3/src/distributions/uniform.rs:441:31: because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false
+rand-0.7.3/src/distributions/uniform.rs:441:31: because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false
+rand-0.7.3/src/distributions/uniform.rs:441:31: because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false
+rand-0.7.3/src/distributions/uniform.rs:441:31: because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false
+rand-0.7.3/src/distributions/uniform.rs:441:31: because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false
+rand-0.7.3/src/distributions/uniform.rs:441:31: because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false
+rand-0.7.3/src/distributions/uniform.rs:441:31: because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false
+rand-0.7.3/src/distributions/uniform.rs:56:10: you should put `SampleBorrow` between ticks in the documentation
+rand-0.7.3/src/distributions/uniform.rs:647:1: item name starts with its containing module's name
+rand-0.7.3/src/distributions/uniform.rs:840:1: item name starts with its containing module's name
+rand-0.7.3/src/distributions/uniform.rs:913:13: use Option::map_or_else instead of an if let/else
+rand-0.7.3/src/distributions/uniform.rs:943:54: casting `u64` to `u32` may truncate the value
+rand-0.7.3/src/distributions/unit_circle.rs:30:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/distributions/unit_sphere.rs:24:1: item name starts with its containing module's name
+rand-0.7.3/src/distributions/unit_sphere.rs:29:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/distributions/utils.rs:247:15: methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name
+rand-0.7.3/src/distributions/utils.rs:248:20: methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name
+rand-0.7.3/src/distributions/utils.rs:249:18: methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name
+rand-0.7.3/src/distributions/utils.rs:254:5: you have declared `#[inline(always)]` on `lanes`. This is usually a bad idea
+rand-0.7.3/src/distributions/utils.rs:258:5: you have declared `#[inline(always)]` on `splat`. This is usually a bad idea
+rand-0.7.3/src/distributions/utils.rs:262:5: you have declared `#[inline(always)]` on `extract`. This is usually a bad idea
+rand-0.7.3/src/distributions/utils.rs:267:5: you have declared `#[inline(always)]` on `replace`. This is usually a bad idea
+rand-0.7.3/src/distributions/utils.rs:281:5: you have declared `#[inline(always)]` on `any`. This is usually a bad idea
+rand-0.7.3/src/distributions/utils.rs:286:5: you have declared `#[inline(always)]` on `all`. This is usually a bad idea
+rand-0.7.3/src/distributions/utils.rs:291:5: you have declared `#[inline(always)]` on `none`. This is usually a bad idea
+rand-0.7.3/src/distributions/utils.rs:488:17: you should put `x_i` between ticks in the documentation
+rand-0.7.3/src/distributions/utils.rs:489:50: you should put `x_i` between ticks in the documentation
+rand-0.7.3/src/distributions/utils.rs:489:63: you should put `f(x_i` between ticks in the documentation
+rand-0.7.3/src/distributions/utils.rs:490:40: you should put `f(x_i` between ticks in the documentation
+rand-0.7.3/src/distributions/utils.rs:490:49: you should put `f(x_{i+1` between ticks in the documentation
+rand-0.7.3/src/distributions/utils.rs:518:17: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
+rand-0.7.3/src/distributions/weibull.rs:29:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/distributions/weighted/alias_method.rs:113:21: it is more concise to loop over references to containers instead of using explicit iteration methods
+rand-0.7.3/src/distributions/weighted/alias_method.rs:125:9: adding items after statements is confusing, since items exist from the start of the scope
+rand-0.7.3/src/distributions/weighted/alias_method.rs:131:9: adding items after statements is confusing, since items exist from the start of the scope
+rand-0.7.3/src/distributions/weighted/alias_method.rs:180:36: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+rand-0.7.3/src/distributions/weighted/alias_method.rs:182:34: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+rand-0.7.3/src/distributions/weighted/alias_method.rs:259:28: using `clone` on type `distributions::uniform::Uniform<u32>` which implements the `Copy` trait
+rand-0.7.3/src/distributions/weighted/alias_method.rs:296:9: you are using an explicit closure for copying elements
+rand-0.7.3/src/distributions/weighted/alias_method.rs:321:9: you are using an explicit closure for copying elements
+rand-0.7.3/src/distributions/weighted/alias_method.rs:78:5: docs for function returning `Result` missing `# Errors` section
+rand-0.7.3/src/distributions/weighted/alias_method.rs:78:5: this function has too many lines (106/100)
+rand-0.7.3/src/distributions/weighted/alias_method.rs:85:17: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+rand-0.7.3/src/distributions/weighted/alias_method.rs:87:31: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
+rand-0.7.3/src/distributions/weighted/mod.rs:100:5: docs for function returning `Result` missing `# Errors` section
+rand-0.7.3/src/distributions/weighted/mod.rs:144:5: docs for function returning `Result` missing `# Errors` section
+rand-0.7.3/src/distributions/weighted/mod.rs:169:16: unnecessary `>= y + 1` or `x - 1 >=`
+rand-0.7.3/src/distributions/weighted/mod.rs:386:1: item name starts with its containing module's name
+rand-0.7.3/src/distributions/weighted/mod.rs:85:1: item name starts with its containing module's name
+rand-0.7.3/src/lib.rs:333:5: docs for function returning `Result` missing `# Errors` section
+rand-0.7.3/src/lib.rs:404:14: methods called `to_*` usually take self by reference; consider choosing a less ambiguous name
+rand-0.7.3/src/lib.rs:552:1: this function could have a `#[must_use]` attribute
+rand-0.7.3/src/rngs/adapter/read.rs:47:1: item name starts with its containing module's name
+rand-0.7.3/src/rngs/adapter/read.rs:89:1: item name starts with its containing module's name
+rand-0.7.3/src/rngs/adapter/reseeding.rs:100:5: docs for function returning `Result` missing `# Errors` section
+rand-0.7.3/src/rngs/adapter/reseeding.rs:112:5: you have declared `#[inline(always)]` on `next_u32`. This is usually a bad idea
+rand-0.7.3/src/rngs/adapter/reseeding.rs:117:5: you have declared `#[inline(always)]` on `next_u64`. This is usually a bad idea
+rand-0.7.3/src/rngs/adapter/reseeding.rs:198:13: casting `u64` to `i64` may wrap around the value
+rand-0.7.3/src/rngs/adapter/reseeding.rs:231:9: casting `usize` to `isize` may wrap around the value
+rand-0.7.3/src/rngs/adapter/reseeding.rs:27:28: you should put `ChaCha` between ticks in the documentation
+rand-0.7.3/src/rngs/adapter/reseeding.rs:79:1: item name starts with its containing module's name
+rand-0.7.3/src/rngs/entropy.rs:24:1: item name starts with its containing module's name
+rand-0.7.3/src/rngs/entropy.rs:34:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/rngs/mock.rs:36:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/rngs/mock.rs:47:9: casting `u64` to `u32` may truncate the value
+rand-0.7.3/src/rngs/mod.rs:61:74: you should put `ChaCha20` between ticks in the documentation
+rand-0.7.3/src/rngs/std.rs:25:39: you should put `ChaCha` between ticks in the documentation
+rand-0.7.3/src/rngs/std.rs:32:10: you should put `rand_chacha` between ticks in the documentation
+rand-0.7.3/src/rngs/std.rs:36:1: item name starts with its containing module's name
+rand-0.7.3/src/rngs/std.rs:39:5: you have declared `#[inline(always)]` on `next_u32`. This is usually a bad idea
+rand-0.7.3/src/rngs/std.rs:44:5: you have declared `#[inline(always)]` on `next_u64`. This is usually a bad idea
+rand-0.7.3/src/rngs/std.rs:49:5: you have declared `#[inline(always)]` on `fill_bytes`. This is usually a bad idea
+rand-0.7.3/src/rngs/std.rs:54:5: you have declared `#[inline(always)]` on `try_fill_bytes`. This is usually a bad idea
+rand-0.7.3/src/rngs/std.rs:63:5: you have declared `#[inline(always)]` on `from_seed`. This is usually a bad idea
+rand-0.7.3/src/rngs/std.rs:68:5: you have declared `#[inline(always)]` on `from_rng`. This is usually a bad idea
+rand-0.7.3/src/rngs/thread.rs:57:1: item name starts with its containing module's name
+rand-0.7.3/src/rngs/thread.rs:80:1: item name starts with its containing module's name
+rand-0.7.3/src/rngs/thread.rs:80:1: this function could have a `#[must_use]` attribute
+rand-0.7.3/src/rngs/thread.rs:81:35: redundant closure found
+rand-0.7.3/src/rngs/thread.rs:93:5: you have declared `#[inline(always)]` on `next_u32`. This is usually a bad idea
+rand-0.7.3/src/rngs/thread.rs:98:5: you have declared `#[inline(always)]` on `next_u64`. This is usually a bad idea
+rand-0.7.3/src/seq/index.rs:127:1: item name starts with its containing module's name
+rand-0.7.3/src/seq/index.rs:139:13: usage of wildcard import for enum variants
+rand-0.7.3/src/seq/index.rs:159:1: item name starts with its containing module's name
+rand-0.7.3/src/seq/index.rs:171:13: usage of wildcard import for enum variants
+rand-0.7.3/src/seq/index.rs:180:13: usage of wildcard import for enum variants
+rand-0.7.3/src/seq/index.rs:223:18: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+rand-0.7.3/src/seq/index.rs:224:18: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+rand-0.7.3/src/seq/index.rs:233:25: casting `u32` to `f32` causes a loss of precision (`u32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)
+rand-0.7.3/src/seq/index.rs:236:27: casting `u32` to `f32` causes a loss of precision (`u32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)
+rand-0.7.3/src/seq/index.rs:244:12: casting `u32` to `f32` causes a loss of precision (`u32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)
+rand-0.7.3/src/seq/index.rs:244:37: casting `u32` to `f32` causes a loss of precision (`u32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)
+rand-0.7.3/src/seq/index.rs:29:1: item name starts with its containing module's name
+rand-0.7.3/src/seq/index.rs:39:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/seq/index.rs:48:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/seq/index.rs:60:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/seq/index.rs:69:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/seq/index.rs:78:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/seq/index.rs:87:5: method `into_iter` can be confused for the standard trait method `std::iter::IntoIterator::into_iter`
+rand-0.7.3/src/seq/index.rs:87:5: this method could have a `#[must_use]` attribute
+rand-0.7.3/src/seq/index.rs:97:13: usage of wildcard import for enum variants
+rand-0.7.3/src/seq/mod.rs:141:5: docs for function returning `Result` missing `# Errors` section
+rand-0.7.3/src/seq/mod.rs:168:5: docs for function returning `Result` missing `# Errors` section
+rand-0.7.3/src/seq/mod.rs:229:4: needless `fn main` in doctest
+rand-0.7.3/src/seq/mod.rs:292:29: casting `usize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`usize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+rand-0.7.3/src/seq/mod.rs:410:23: calling `std::marker::PhantomData::default()` is more clear than this expression
+rand-0.7.3/src/seq/mod.rs:45:4: needless `fn main` in doctest
+rand-0.7.3/src/seq/mod.rs:527:26: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
 rand_core-0.6.0/src/block.rs:117:1: item name starts with its containing module's name
 rand_core-0.6.0/src/block.rs:153:5: you have declared `#[inline(always)]` on `index`. This is usually a bad idea
 rand_core-0.6.0/src/block.rs:230:5: you have declared `#[inline(always)]` on `try_fill_bytes`. This is usually a bad idea
@@ -2694,559 +2249,996 @@ rand_core-0.6.0/src/lib.rs:381:5: you have declared `#[inline(always)]` on `next
 rand_core-0.6.0/src/lib.rs:386:5: you have declared `#[inline(always)]` on `next_u64`. This is usually a bad idea
 rand_core-0.6.0/src/lib.rs:391:5: you have declared `#[inline(always)]` on `fill_bytes`. This is usually a bad idea
 rand_core-0.6.0/src/lib.rs:396:5: you have declared `#[inline(always)]` on `try_fill_bytes`. This is usually a bad idea
-unicode-xid-0.2.1/src/lib.rs:57:64: you should put `XID_Start` between ticks in the documentation
-unicode-xid-0.2.1/src/lib.rs:60:10: you should put `XID_Start` between ticks in the documentation
-unicode-xid-0.2.1/src/lib.rs:62:27: you should put `ID_Start` between ticks in the documentation
-unicode-xid-0.2.1/src/lib.rs:62:67: you should put `NFKx` between ticks in the documentation
-unicode-xid-0.2.1/src/lib.rs:65:61: you should put `XID_Continue` between ticks in the documentation
-unicode-xid-0.2.1/src/lib.rs:68:10: you should put `XID_Continue` between ticks in the documentation
-unicode-xid-0.2.1/src/lib.rs:70:28: you should put `ID_Continue` between ticks in the documentation
-unicode-xid-0.2.1/src/lib.rs:70:72: you should put `NFKx` between ticks in the documentation
-proc-macro2-1.0.24/src/detection.rs:2:5: usage of wildcard import
-proc-macro2-1.0.24/src/fallback.rs:108:17: wildcard match will miss any future added variants
-proc-macro2-1.0.24/src/fallback.rs:269:20: unused `self` argument
-proc-macro2-1.0.24/src/fallback.rs:430:24: this argument (0 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-proc-macro2-1.0.24/src/fallback.rs:437:23: this argument (0 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-proc-macro2-1.0.24/src/fallback.rs:437:23: unused `self` argument
-proc-macro2-1.0.24/src/fallback.rs:471:17: this argument (0 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-proc-macro2-1.0.24/src/fallback.rs:471:17: unused `self` argument
-proc-macro2-1.0.24/src/fallback.rs:654:5: manual `RangeInclusive::contains` implementation
-proc-macro2-1.0.24/src/fallback.rs:655:12: manual `RangeInclusive::contains` implementation
-proc-macro2-1.0.24/src/fallback.rs:661:5: manual `RangeInclusive::contains` implementation
-proc-macro2-1.0.24/src/fallback.rs:662:12: manual `RangeInclusive::contains` implementation
-proc-macro2-1.0.24/src/fallback.rs:664:12: manual `RangeInclusive::contains` implementation
-proc-macro2-1.0.24/src/fallback.rs:674:37: manual `RangeInclusive::contains` implementation
-proc-macro2-1.0.24/src/fallback.rs:678:5: adding items after statements is confusing, since items exist from the start of the scope
-proc-macro2-1.0.24/src/fallback.rs:85:9: adding items after statements is confusing, since items exist from the start of the scope
-proc-macro2-1.0.24/src/fallback.rs:882:43: unused `self` argument
-proc-macro2-1.0.24/src/lib.rs:1017:9: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:1081:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:1099:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:1117:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:1135:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:1141:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:1146:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:1151:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:1156:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:152:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:157:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:373:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:383:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:397:24: this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-proc-macro2-1.0.24/src/lib.rs:397:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:403:23: this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-proc-macro2-1.0.24/src/lib.rs:403:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:418:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:425:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:464:17: this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-proc-macro2-1.0.24/src/lib.rs:500:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:626:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:633:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:641:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:652:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:662:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:672:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:734:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:743:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:752:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:757:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:788:19: you should put `XID_Start` between ticks in the documentation
-proc-macro2-1.0.24/src/lib.rs:788:69: you should put `XID_Continue` between ticks in the documentation
-proc-macro2-1.0.24/src/lib.rs:891:36: you should put `syn::parse_str` between ticks in the documentation
-proc-macro2-1.0.24/src/lib.rs:894:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:911:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:996:9: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/parse.rs:552:5: this loop could be written as a `for` loop
-proc-macro2-1.0.24/src/parse.rs:584:21: manual `RangeInclusive::contains` implementation
-proc-macro2-1.0.24/src/parse.rs:602:20: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
-proc-macro2-1.0.24/src/parse.rs:696:29: casting `u8` to `u64` may become silently lossy if you later change the type
-proc-macro2-1.0.24/src/parse.rs:702:34: casting `u8` to `u64` may become silently lossy if you later change the type
-proc-macro2-1.0.24/src/parse.rs:708:34: casting `u8` to `u64` may become silently lossy if you later change the type
-proc-macro2-1.0.24/src/parse.rs:803:15: it is more concise to loop over references to containers instead of using explicit iteration methods
-proc-macro2-1.0.24/src/parse.rs:808:15: it is more concise to loop over references to containers instead of using explicit iteration methods
-proc-macro2-1.0.24/src/wrapper.rs:415:24: this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-proc-macro2-1.0.24/src/wrapper.rs:429:23: this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-proc-macro2-1.0.24/src/wrapper.rs:492:17: this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-log-0.4.11/src/lib.rs:1047:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:1053:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:1059:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:1093:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:1093:5: you should consider adding a `Default` implementation for `MetadataBuilder<'a>`
-log-0.4.11/src/lib.rs:1118:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:1177:1: you have declared `#[inline(always)]` on `max_level`. This is usually a bad idea
-log-0.4.11/src/lib.rs:1178:1: this function could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:1306:1: docs for function returning `Result` missing `# Errors` section
-log-0.4.11/src/lib.rs:1358:1: this function could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:1359:5: unnecessary `!=` operation
-log-0.4.11/src/lib.rs:1407:1: this function could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:329:27: you are deriving `Hash` but have implemented `PartialEq` explicitly
-log-0.4.11/src/lib.rs:356:1: you are implementing `Clone` explicitly on a `Copy` type
-log-0.4.11/src/lib.rs:448:12: manual `RangeInclusive::contains` implementation
-log-0.4.11/src/lib.rs:468:13: called `filter(..).map(..)` on an `Iterator`
-log-0.4.11/src/lib.rs:500:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:506:28: this argument (8 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-log-0.4.11/src/lib.rs:506:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:520:27: you are deriving `Hash` but have implemented `PartialEq` explicitly
-log-0.4.11/src/lib.rs:538:1: you are implementing `Clone` explicitly on a `Copy` type
-log-0.4.11/src/lib.rs:653:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:661:21: this argument (8 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-log-0.4.11/src/lib.rs:661:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:677:44: this `match` has identical arm bodies
-log-0.4.11/src/lib.rs:758:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:764:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:770:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:776:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:782:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:788:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:794:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:803:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:809:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:818:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:908:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:908:5: you should consider adding a `Default` implementation for `RecordBuilder<'a>`
-log-0.4.11/src/lib.rs:995:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/backtrack.rs:100:13: redundant field names in struct initialization
-regex-1.4.2/src/backtrack.rs:133:17: it looks like the same item is being pushed into this Vec
-regex-1.4.2/src/backtrack.rs:145:20: unnecessary boolean `not` operation
-regex-1.4.2/src/backtrack.rs:199:13: usage of wildcard import for enum variants
-regex-1.4.2/src/backtrack.rs:223:29: redundant field names in struct initialization
-regex-1.4.2/src/backtrack.rs:230:66: redundant field names in struct initialization
-regex-1.4.2/src/backtrack.rs:284:21: casting `u32` to `u64` may become silently lossy if you later change the type
-regex-1.4.2/src/backtrack.rs:287:5: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-regex-1.4.2/src/backtrack.rs:97:13: redundant field names in struct initialization
-regex-1.4.2/src/backtrack.rs:98:13: redundant field names in struct initialization
-regex-1.4.2/src/backtrack.rs:99:13: redundant field names in struct initialization
-regex-1.4.2/src/compile.rs:1000:17: redundant field names in struct initialization
-regex-1.4.2/src/compile.rs:103:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/compile.rs:1048:17: you should put `HashMap` between ticks in the documentation
-regex-1.4.2/src/compile.rs:1075:26: integer type suffix should be separated by an underscore
-regex-1.4.2/src/compile.rs:1089:44: redundant field names in struct initialization
-regex-1.4.2/src/compile.rs:1089:54: redundant field names in struct initialization
-regex-1.4.2/src/compile.rs:1100:32: long literal lacking separators
-regex-1.4.2/src/compile.rs:1101:21: long literal lacking separators
-regex-1.4.2/src/compile.rs:1103:18: casting `u8` to `u64` may become silently lossy if you later change the type
-regex-1.4.2/src/compile.rs:1104:18: casting `u8` to `u64` may become silently lossy if you later change the type
-regex-1.4.2/src/compile.rs:1105:9: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
-regex-1.4.2/src/compile.rs:1132:37: casting `u16` to `u8` may truncate the value
-regex-1.4.2/src/compile.rs:1132:55: casting `u16` to `u8` may truncate the value
-regex-1.4.2/src/compile.rs:1135:28: casting `u16` to `u8` may truncate the value
-regex-1.4.2/src/compile.rs:1135:38: casting `u16` to `u8` may truncate the value
-regex-1.4.2/src/compile.rs:113:5: docs for function returning `Result` missing `# Errors` section
-regex-1.4.2/src/compile.rs:1146:25: integer type suffix should be separated by an underscore
-regex-1.4.2/src/compile.rs:1166:8: casting `u32` to `u64` may become silently lossy if you later change the type
-regex-1.4.2/src/compile.rs:136:46: use of `unwrap_or` followed by a function call
-regex-1.4.2/src/compile.rs:155:30: redundant closure found
-regex-1.4.2/src/compile.rs:157:30: redundant closure found
-regex-1.4.2/src/compile.rs:172:42: use of `unwrap_or` followed by a function call
-regex-1.4.2/src/compile.rs:180:43: use of `unwrap_or` followed by a function call
-regex-1.4.2/src/compile.rs:188:5: this function's return value is unnecessarily wrapped by `Result`
-regex-1.4.2/src/compile.rs:190:40: redundant closure found
-regex-1.4.2/src/compile.rs:204:53: you should put `MaybeInsts` between ticks in the documentation
-regex-1.4.2/src/compile.rs:244:63: you should put `c_concat` between ticks in the documentation
-regex-1.4.2/src/compile.rs:251:5: this function has too many lines (111/100)
-regex-1.4.2/src/compile.rs:253:13: usage of wildcard import for enum variants
-regex-1.4.2/src/compile.rs:375:39: use of `unwrap_or` followed by a function call
-regex-1.4.2/src/compile.rs:379:29: redundant field names in struct initialization
-regex-1.4.2/src/compile.rs:379:41: redundant field names in struct initialization
-regex-1.4.2/src/compile.rs:384:12: unnecessary boolean `not` operation
-regex-1.4.2/src/compile.rs:413:56: redundant field names in struct initialization
-regex-1.4.2/src/compile.rs:421:45: redundant field names in struct initialization
-regex-1.4.2/src/compile.rs:428:51: redundant field names in struct initialization
-regex-1.4.2/src/compile.rs:430:29: redundant field names in struct initialization
-regex-1.4.2/src/compile.rs:438:5: this function's return value is unnecessarily wrapped by `Result`
-regex-1.4.2/src/compile.rs:43:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/compile.rs:43:5: you should consider adding a `Default` implementation for `compile::Compiler`
-regex-1.4.2/src/compile.rs:468:5: this function's return value is unnecessarily wrapped by `Result`
-regex-1.4.2/src/compile.rs:469:57: redundant field names in struct initialization
-regex-1.4.2/src/compile.rs:470:25: redundant field names in struct initialization
-regex-1.4.2/src/compile.rs:494:25: redundant field names in struct initialization
-regex-1.4.2/src/compile.rs:494:37: redundant field names in struct initialization
-regex-1.4.2/src/compile.rs:547:13: usage of wildcard import for enum variants
-regex-1.4.2/src/compile.rs:56:57: you should put `size_limit` between ticks in the documentation
-regex-1.4.2/src/compile.rs:59:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/compile.rs:637:14: use of `unwrap_or` followed by a function call
-regex-1.4.2/src/compile.rs:638:9: use Option::map_or instead of an if let/else
-regex-1.4.2/src/compile.rs:661:41: use of `unwrap_or` followed by a function call
-regex-1.4.2/src/compile.rs:703:9: you should put `c_function` between ticks in the documentation
-regex-1.4.2/src/compile.rs:75:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/compile.rs:786:5: this function's return value is unnecessarily wrapped by `Result`
-regex-1.4.2/src/compile.rs:838:21: redundant field names in struct initialization
-regex-1.4.2/src/compile.rs:845:21: redundant field names in struct initialization
-regex-1.4.2/src/compile.rs:848:13: wildcard match will miss any future added variants
-regex-1.4.2/src/compile.rs:84:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/compile.rs:860:41: redundant field names in struct initialization
-regex-1.4.2/src/compile.rs:860:55: redundant field names in struct initialization
-regex-1.4.2/src/compile.rs:920:39: redundant field names in struct initialization
-regex-1.4.2/src/compile.rs:920:51: redundant field names in struct initialization
-regex-1.4.2/src/compile.rs:923:49: redundant field names in struct initialization
-regex-1.4.2/src/compile.rs:923:61: redundant field names in struct initialization
-regex-1.4.2/src/compile.rs:925:59: redundant field names in struct initialization
-regex-1.4.2/src/compile.rs:925:71: redundant field names in struct initialization
-regex-1.4.2/src/compile.rs:927:43: redundant field names in struct initialization
-regex-1.4.2/src/compile.rs:930:41: redundant field names in struct initialization
-regex-1.4.2/src/compile.rs:930:53: redundant field names in struct initialization
-regex-1.4.2/src/compile.rs:930:67: redundant field names in struct initialization
-regex-1.4.2/src/compile.rs:96:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/compile.rs:991:5: this function's return value is unnecessarily wrapped by `Result`
-regex-1.4.2/src/dfa.rs:1007:17: binding's name is too similar to existing binding
-regex-1.4.2/src/dfa.rs:1010:22: binding's name is too similar to existing binding
-regex-1.4.2/src/dfa.rs:1059:13: usage of wildcard import for enum variants
-regex-1.4.2/src/dfa.rs:1060:13: usage of wildcard import for enum variants
-regex-1.4.2/src/dfa.rs:1084:38: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-regex-1.4.2/src/dfa.rs:1087:38: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-regex-1.4.2/src/dfa.rs:1090:38: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-regex-1.4.2/src/dfa.rs:1093:38: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-regex-1.4.2/src/dfa.rs:1096:38: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-regex-1.4.2/src/dfa.rs:1101:38: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-regex-1.4.2/src/dfa.rs:1104:38: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-regex-1.4.2/src/dfa.rs:1107:38: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-regex-1.4.2/src/dfa.rs:1117:30: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-regex-1.4.2/src/dfa.rs:1120:47: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-regex-1.4.2/src/dfa.rs:1121:30: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-regex-1.4.2/src/dfa.rs:1129:13: you should put `is_match` between ticks in the documentation
-regex-1.4.2/src/dfa.rs:1134:13: you should put `is_match` between ticks in the documentation
-regex-1.4.2/src/dfa.rs:1185:68: you should put `is_match` between ticks in the documentation
-regex-1.4.2/src/dfa.rs:1193:13: usage of wildcard import for enum variants
-regex-1.4.2/src/dfa.rs:1244:50: you should put `current_state` between ticks in the documentation
-regex-1.4.2/src/dfa.rs:1338:58: you should put `STATE_DEAD` between ticks in the documentation
-regex-1.4.2/src/dfa.rs:1339:9: you should put `STATE_UNKNOWN` between ticks in the documentation
-regex-1.4.2/src/dfa.rs:1366:25: you should put `STATE_DEAD` between ticks in the documentation
-regex-1.4.2/src/dfa.rs:1366:46: you should put `STATE_UNKNOWN` between ticks in the documentation
-regex-1.4.2/src/dfa.rs:1367:41: you have declared `#[inline(always)]` on `start_state`. This is usually a bad idea
-regex-1.4.2/src/dfa.rs:1380:14: the operation is ineffective. Consider reducing it to `(empty_flags.start as u8)`
-regex-1.4.2/src/dfa.rs:1388:15: indexing into a vector may panic
-regex-1.4.2/src/dfa.rs:1412:20: unused `self` argument
-regex-1.4.2/src/dfa.rs:1438:9: unused `self` argument
-regex-1.4.2/src/dfa.rs:1472:9: you should put `StatePtr` between ticks in the documentation
-regex-1.4.2/src/dfa.rs:1490:54: casting `i32` to `u8` may lose the sign of the value
-regex-1.4.2/src/dfa.rs:1490:54: casting `i32` to `u8` may truncate the value
-regex-1.4.2/src/dfa.rs:1521:20: you should put `num_byte_classes` between ticks in the documentation
-regex-1.4.2/src/dfa.rs:1529:41: you have declared `#[inline(always)]` on `byte_class`. This is usually a bad idea
-regex-1.4.2/src/dfa.rs:1537:14: you should put `byte_class` between ticks in the documentation
-regex-1.4.2/src/dfa.rs:1538:41: you have declared `#[inline(always)]` on `u8_class`. This is usually a bad idea
-regex-1.4.2/src/dfa.rs:1562:18: you should put `STATE_START` between ticks in the documentation
-regex-1.4.2/src/dfa.rs:1614:13: redundant field names in struct initialization
-regex-1.4.2/src/dfa.rs:1651:38: redundant field names in struct initialization
-regex-1.4.2/src/dfa.rs:1700:17: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-regex-1.4.2/src/dfa.rs:1701:18: digits of hex or binary literal not grouped by four
-regex-1.4.2/src/dfa.rs:1705:19: digits of hex or binary literal not grouped by four
-regex-1.4.2/src/dfa.rs:1708:16: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-regex-1.4.2/src/dfa.rs:1709:18: digits of hex or binary literal not grouped by four
-regex-1.4.2/src/dfa.rs:1713:19: digits of hex or binary literal not grouped by four
-regex-1.4.2/src/dfa.rs:1716:18: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-regex-1.4.2/src/dfa.rs:1717:18: digits of hex or binary literal not grouped by four
-regex-1.4.2/src/dfa.rs:1721:19: digits of hex or binary literal not grouped by four
-regex-1.4.2/src/dfa.rs:1727:14: casting `u8` to `u16` may become silently lossy if you later change the type
-regex-1.4.2/src/dfa.rs:1732:15: this argument (2 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-regex-1.4.2/src/dfa.rs:1736:22: this argument (2 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-regex-1.4.2/src/dfa.rs:1741:9: match expression looks like `matches!` macro
-regex-1.4.2/src/dfa.rs:1747:16: this argument (2 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-regex-1.4.2/src/dfa.rs:1751:18: casting `u16` to `u8` may truncate the value
-regex-1.4.2/src/dfa.rs:1815:38: casting `usize` to `u8` may truncate the value
-regex-1.4.2/src/dfa.rs:1821:21: casting `u32` to `u64` may become silently lossy if you later change the type
-regex-1.4.2/src/dfa.rs:1824:5: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-regex-1.4.2/src/dfa.rs:1848:5: you should put bare URLs between `<`/`>` or make a proper Markdown link
-regex-1.4.2/src/dfa.rs:1850:18: casting `i32` to `u32` may lose the sign of the value
-regex-1.4.2/src/dfa.rs:1857:5: you should put bare URLs between `<`/`>` or make a proper Markdown link
-regex-1.4.2/src/dfa.rs:1860:17: casting `u32` to `i32` may wrap around the value
-regex-1.4.2/src/dfa.rs:1867:5: you should put bare URLs between `<`/`>` or make a proper Markdown link
-regex-1.4.2/src/dfa.rs:1870:19: casting `u32` to `u8` may truncate the value
-regex-1.4.2/src/dfa.rs:1873:15: casting `u32` to `u8` may truncate the value
-regex-1.4.2/src/dfa.rs:1876:5: you should put bare URLs between `<`/`>` or make a proper Markdown link
-regex-1.4.2/src/dfa.rs:1882:26: casting `u8` to `u32` may become silently lossy if you later change the type
-regex-1.4.2/src/dfa.rs:1884:15: casting `u8` to `u32` may become silently lossy if you later change the type
-regex-1.4.2/src/dfa.rs:277:17: casting `u32` to `i32` may wrap around the value
-regex-1.4.2/src/dfa.rs:277:31: casting `u32` to `i32` may wrap around the value
-regex-1.4.2/src/dfa.rs:295:20: casting `usize` to `i32` may truncate the value on targets with 64-bit wide pointers
-regex-1.4.2/src/dfa.rs:295:20: casting `usize` to `i32` may wrap around the value on targets with 32-bit wide pointers
-regex-1.4.2/src/dfa.rs:299:21: casting `i32` to `usize` may lose the sign of the value
-regex-1.4.2/src/dfa.rs:34:46: you should put bare URLs between `<`/`>` or make a proper Markdown link
-regex-1.4.2/src/dfa.rs:398:1: more than 3 bools in a struct
-regex-1.4.2/src/dfa.rs:446:41: you have declared `#[inline(always)]` on `forward`. This is usually a bad idea
-regex-1.4.2/src/dfa.rs:457:13: redundant field names in struct initialization
-regex-1.4.2/src/dfa.rs:459:13: redundant field names in struct initialization
-regex-1.4.2/src/dfa.rs:460:13: redundant field names in struct initialization
-regex-1.4.2/src/dfa.rs:476:41: you have declared `#[inline(always)]` on `reverse`. This is usually a bad idea
-regex-1.4.2/src/dfa.rs:487:13: redundant field names in struct initialization
-regex-1.4.2/src/dfa.rs:489:13: redundant field names in struct initialization
-regex-1.4.2/src/dfa.rs:490:13: redundant field names in struct initialization
-regex-1.4.2/src/dfa.rs:506:41: you have declared `#[inline(always)]` on `forward_many`. This is usually a bad idea
-regex-1.4.2/src/dfa.rs:518:13: redundant field names in struct initialization
-regex-1.4.2/src/dfa.rs:520:13: redundant field names in struct initialization
-regex-1.4.2/src/dfa.rs:554:41: you have declared `#[inline(always)]` on `exec_at`. This is usually a bad idea
-regex-1.4.2/src/dfa.rs:555:5: this function has too many lines (101/100)
-regex-1.4.2/src/dfa.rs:58:9: usage of wildcard import for enum variants
-regex-1.4.2/src/dfa.rs:667:21: binding's name is too similar to existing binding
-regex-1.4.2/src/dfa.rs:747:41: you have declared `#[inline(always)]` on `exec_at_reverse`. This is usually a bad idea
-regex-1.4.2/src/dfa.rs:795:21: binding's name is too similar to existing binding
-regex-1.4.2/src/dfa.rs:848:9: you should put `next_si` between ticks in the documentation
-regex-1.4.2/src/dfa.rs:852:41: you have declared `#[inline(always)]` on `next_si`. This is usually a bad idea
-regex-1.4.2/src/dfa.rs:885:12: you should put `STATE_DEAD` between ticks in the documentation
-regex-1.4.2/src/dfa.rs:889:9: you should put `STATE_UNKNOWN` between ticks in the documentation
-regex-1.4.2/src/dfa.rs:897:13: usage of wildcard import for enum variants
-regex-1.4.2/src/dfa.rs:979:29: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-regex-1.4.2/src/error.rs:6:1: this seems like a manual implementation of the non-exhaustive pattern
-regex-1.4.2/src/exec.rs:1000:14: you should put `captures_nfa` between ticks in the documentation
-regex-1.4.2/src/exec.rs:100:1: item name starts with its containing module's name
-regex-1.4.2/src/exec.rs:1028:5: this function has too many arguments (9/7)
-regex-1.4.2/src/exec.rs:1039:13: usage of wildcard import for enum variants
-regex-1.4.2/src/exec.rs:1144:13: usage of wildcard import for enum variants
-regex-1.4.2/src/exec.rs:1179:26: this `match` has identical arm bodies
-regex-1.4.2/src/exec.rs:122:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/exec.rs:1250:41: you have declared `#[inline(always)]` on `searcher`. This is usually a bad idea
-regex-1.4.2/src/exec.rs:1260:41: you have declared `#[inline(always)]` on `searcher_str`. This is usually a bad idea
-regex-1.4.2/src/exec.rs:1270:17: you should put `RegexSet` between ticks in the documentation
-regex-1.4.2/src/exec.rs:1280:17: you should put `RegexSet` between ticks in the documentation
-regex-1.4.2/src/exec.rs:137:9: field assignment outside of initializer for an instance created with Default::default()
-regex-1.4.2/src/exec.rs:142:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/exec.rs:158:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/exec.rs:168:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/exec.rs:181:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/exec.rs:195:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/exec.rs:204:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/exec.rs:210:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/exec.rs:245:62: this `if` has identical blocks
-regex-1.4.2/src/exec.rs:251:21: unnecessary boolean `not` operation
-regex-1.4.2/src/exec.rs:262:60: this `if` has identical blocks
-regex-1.4.2/src/exec.rs:268:21: unnecessary boolean `not` operation
-regex-1.4.2/src/exec.rs:278:13: redundant field names in struct initialization
-regex-1.4.2/src/exec.rs:281:13: redundant field names in struct initialization
-regex-1.4.2/src/exec.rs:286:5: docs for function returning `Result` missing `# Errors` section
-regex-1.4.2/src/exec.rs:300:30: redundant field names in struct initialization
-regex-1.4.2/src/exec.rs:308:17: binding's name is too similar to existing binding
-regex-1.4.2/src/exec.rs:329:13: redundant field names in struct initialization
-regex-1.4.2/src/exec.rs:330:13: redundant field names in struct initialization
-regex-1.4.2/src/exec.rs:331:13: redundant field names in struct initialization
-regex-1.4.2/src/exec.rs:334:13: redundant field names in struct initialization
-regex-1.4.2/src/exec.rs:340:19: redundant field names in struct initialization
-regex-1.4.2/src/exec.rs:344:27: unused `self` argument
-regex-1.4.2/src/exec.rs:383:41: you have declared `#[inline(always)]` on `shortest_match_at`. This is usually a bad idea
-regex-1.4.2/src/exec.rs:388:41: you have declared `#[inline(always)]` on `is_match_at`. This is usually a bad idea
-regex-1.4.2/src/exec.rs:393:41: you have declared `#[inline(always)]` on `find_at`. This is usually a bad idea
-regex-1.4.2/src/exec.rs:398:41: you have declared `#[inline(always)]` on `captures_read_at`. This is usually a bad idea
-regex-1.4.2/src/exec.rs:425:41: you have declared `#[inline(always)]` on `shortest_match_at`. This is usually a bad idea
-regex-1.4.2/src/exec.rs:44:1: item name starts with its containing module's name
-regex-1.4.2/src/exec.rs:473:9: you should put `shortest_match(...).is_some` between ticks in the documentation
-regex-1.4.2/src/exec.rs:474:41: you have declared `#[inline(always)]` on `is_match_at`. This is usually a bad idea
-regex-1.4.2/src/exec.rs:524:41: you have declared `#[inline(always)]` on `find_at`. This is usually a bad idea
-regex-1.4.2/src/exec.rs:52:1: item name starts with its containing module's name
-regex-1.4.2/src/exec.rs:686:13: usage of wildcard import for enum variants
-regex-1.4.2/src/exec.rs:727:13: usage of wildcard import for enum variants
-regex-1.4.2/src/exec.rs:767:13: usage of wildcard import for enum variants
-regex-1.4.2/src/exec.rs:783:41: you have declared `#[inline(always)]` on `shortest_dfa`. This is usually a bad idea
-regex-1.4.2/src/exec.rs:791:41: you have declared `#[inline(always)]` on `shortest_dfa_reverse_suffix`. This is usually a bad idea
-regex-1.4.2/src/exec.rs:823:13: usage of wildcard import for enum variants
-regex-1.4.2/src/exec.rs:868:13: usage of wildcard import for enum variants
-regex-1.4.2/src/exec.rs:897:31: you should put `shortest_nfa(...).is_some` between ticks in the documentation
-regex-1.4.2/src/exec.rs:899:9: you should put `shortest_nfa` between ticks in the documentation
-regex-1.4.2/src/exec.rs:905:14: you should put `match_nfa` between ticks in the documentation
-regex-1.4.2/src/exec.rs:930:14: you should put `shortest_nfa` between ticks in the documentation
-regex-1.4.2/src/exec.rs:981:14: you should put `find_nfa` between ticks in the documentation
-regex-1.4.2/src/expand.rs:130:22: this call to `as_ref` does nothing
-regex-1.4.2/src/expand.rs:185:27: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-regex-1.4.2/src/expand.rs:186:5: match expression looks like `matches!` macro
-regex-1.4.2/src/expand.rs:22:13: calling `push_str()` using a single-character string literal
-regex-1.4.2/src/expand.rs:27:23: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-regex-1.4.2/src/expand.rs:30:17: calling `push_str()` using a single-character string literal
-regex-1.4.2/src/expand.rs:38:30: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
-regex-1.4.2/src/expand.rs:42:21: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
-regex-1.4.2/src/expand.rs:50:1: item name starts with its containing module's name
-regex-1.4.2/src/expand.rs:69:23: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-regex-1.4.2/src/expand.rs:80:28: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
-regex-1.4.2/src/expand.rs:84:21: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
-regex-1.4.2/src/expand.rs:8:1: item name starts with its containing module's name
-regex-1.4.2/src/input.rs:142:1: item name ends with its containing module's name
-regex-1.4.2/src/input.rs:146:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/input.rs:15:1: item name starts with its containing module's name
-regex-1.4.2/src/input.rs:165:31: redundant field names in struct initialization
-regex-1.4.2/src/input.rs:178:13: usage of wildcard import for enum variants
-regex-1.4.2/src/input.rs:228:1: item name ends with its containing module's name
-regex-1.4.2/src/input.rs:236:21: redundant field names in struct initialization
-regex-1.4.2/src/input.rs:236:33: redundant field names in struct initialization
-regex-1.4.2/src/input.rs:24:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/input.rs:271:13: usage of wildcard import for enum variants
-regex-1.4.2/src/input.rs:29:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/input.rs:362:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/input.rs:370:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/input.rs:371:42: redundant closure found
-regex-1.4.2/src/input.rs:37:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/input.rs:388:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/input.rs:42:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/input.rs:47:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/input.rs:53:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/input.rs:58:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/input.rs:63:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/literal/imp.rs:101:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/literal/imp.rs:114:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/literal/imp.rs:127:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/literal/imp.rs:139:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/literal/imp.rs:144:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/literal/imp.rs:149:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/literal/imp.rs:154:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/literal/imp.rs:155:13: usage of wildcard import for enum variants
-regex-1.4.2/src/literal/imp.rs:160:30: this `match` has identical arm bodies
-regex-1.4.2/src/literal/imp.rs:167:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/literal/imp.rs:168:13: usage of wildcard import for enum variants
-regex-1.4.2/src/literal/imp.rs:211:20: redundant else block
-regex-1.4.2/src/literal/imp.rs:276:50: this `match` has identical arm bodies
-regex-1.4.2/src/literal/imp.rs:342:41: you have declared `#[inline(always)]` on `find`. This is usually a bad idea
-regex-1.4.2/src/literal/imp.rs:435:13: redundant field names in struct initialization
-regex-1.4.2/src/literal/imp.rs:436:13: redundant field names in struct initialization
-regex-1.4.2/src/literal/imp.rs:437:13: redundant field names in struct initialization
-regex-1.4.2/src/literal/imp.rs:438:13: redundant field names in struct initialization
-regex-1.4.2/src/literal/imp.rs:439:13: redundant field names in struct initialization
-regex-1.4.2/src/literal/imp.rs:440:13: redundant field names in struct initialization
-regex-1.4.2/src/literal/imp.rs:455:41: you have declared `#[inline(always)]` on `find`. This is usually a bad idea
-regex-1.4.2/src/literal/imp.rs:46:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/literal/imp.rs:481:41: you have declared `#[inline(always)]` on `is_suffix`. This is usually a bad idea
-regex-1.4.2/src/literal/imp.rs:51:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/literal/imp.rs:579:13: redundant field names in struct initialization
-regex-1.4.2/src/literal/imp.rs:57:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/literal/imp.rs:580:13: redundant field names in struct initialization
-regex-1.4.2/src/literal/imp.rs:583:13: redundant field names in struct initialization
-regex-1.4.2/src/literal/imp.rs:602:9: adding items after statements is confusing, since items exist from the start of the scope
-regex-1.4.2/src/literal/imp.rs:622:24: redundant else block
-regex-1.4.2/src/literal/imp.rs:62:18: this argument is passed by value, but not consumed in the function body
-regex-1.4.2/src/literal/imp.rs:637:24: redundant else block
-regex-1.4.2/src/literal/imp.rs:648:9: unneeded `return` statement
-regex-1.4.2/src/literal/imp.rs:651:44: you should put `BoyerMooreSearch` between ticks in the documentation
-regex-1.4.2/src/literal/imp.rs:65:13: redundant field names in struct initialization
-regex-1.4.2/src/literal/imp.rs:68:13: redundant field names in struct initialization
-regex-1.4.2/src/literal/imp.rs:783:32: redundant else block
-regex-1.4.2/src/literal/imp.rs:786:42: manual saturating arithmetic
-regex-1.4.2/src/literal/imp.rs:78:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/literal/imp.rs:84:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/literal/imp.rs:850:20: long literal lacking separators
-regex-1.4.2/src/literal/imp.rs:85:13: usage of wildcard import for enum variants
-regex-1.4.2/src/pikevm.rs:103:15: redundant field names in struct initialization
-regex-1.4.2/src/pikevm.rs:103:52: redundant field names in struct initialization
-regex-1.4.2/src/pikevm.rs:114:5: this function has too many arguments (8/7)
-regex-1.4.2/src/pikevm.rs:117:13: binding's name is too similar to existing binding
-regex-1.4.2/src/pikevm.rs:124:17: binding's name is too similar to existing binding
-regex-1.4.2/src/pikevm.rs:220:9: you should put `thread_caps` between ticks in the documentation
-regex-1.4.2/src/pikevm.rs:222:16: you should put `at_next` between ticks in the documentation
-regex-1.4.2/src/pikevm.rs:223:9: you should put `at_next` between ticks in the documentation
-regex-1.4.2/src/pikevm.rs:224:5: this function has too many arguments (8/7)
-regex-1.4.2/src/pikevm.rs:234:13: usage of wildcard import for enum variants
-regex-1.4.2/src/pikevm.rs:303:13: usage of wildcard import for enum variants
-regex-1.4.2/src/pikevm.rs:331:29: this expression mutably borrows a mutable reference. Consider reborrowing
-regex-1.4.2/src/pikevm.rs:88:5: this function has too many arguments (8/7)
-regex-1.4.2/src/prog.rs:102:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/prog.rs:113:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/prog.rs:120:9: match expression looks like `matches!` macro
-regex-1.4.2/src/prog.rs:128:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/prog.rs:134:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/prog.rs:141:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/prog.rs:147:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/prog.rs:164:41: you have declared `#[inline(always)]` on `deref`. This is usually a bad idea
-regex-1.4.2/src/prog.rs:172:13: usage of wildcard import for enum variants
-regex-1.4.2/src/prog.rs:18:1: more than 3 bools in a struct
-regex-1.4.2/src/prog.rs:236:13: using `write!()` with a format string that ends in a single newline
-regex-1.4.2/src/prog.rs:300:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/prog.rs:301:9: match expression looks like `matches!` macro
-regex-1.4.2/src/prog.rs:382:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/prog.rs:409:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/prog.rs:80:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/prog.rs:80:5: you should consider adding a `Default` implementation for `prog::Program`
-regex-1.4.2/src/re_builder.rs:267:17: docs for function returning `Result` missing `# Errors` section
-regex-1.4.2/src/re_builder.rs:267:17: docs for function returning `Result` missing `# Errors` section
-regex-1.4.2/src/re_builder.rs:4:1: more than 3 bools in a struct
-regex-1.4.2/src/re_builder.rs:57:17: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/re_builder.rs:57:17: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/re_builder.rs:68:17: docs for function returning `Result` missing `# Errors` section
-regex-1.4.2/src/re_builder.rs:68:17: docs for function returning `Result` missing `# Errors` section
-regex-1.4.2/src/re_bytes.rs:1023:9: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
-regex-1.4.2/src/re_bytes.rs:1045:9: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
-regex-1.4.2/src/re_bytes.rs:1100:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-regex-1.4.2/src/re_bytes.rs:1125:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-regex-1.4.2/src/re_bytes.rs:1140:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-regex-1.4.2/src/re_bytes.rs:118:5: docs for function returning `Result` missing `# Errors` section
-regex-1.4.2/src/re_bytes.rs:257:13: redundant field names in struct initialization
-regex-1.4.2/src/re_bytes.rs:29:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/re_bytes.rs:35:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/re_bytes.rs:42:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/re_bytes.rs:48:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/re_bytes.rs:559:29: you should put `shortest_match` between ticks in the documentation
-regex-1.4.2/src/re_bytes.rs:55:33: redundant field names in struct initialization
-regex-1.4.2/src/re_bytes.rs:55:47: redundant field names in struct initialization
-regex-1.4.2/src/re_bytes.rs:573:29: you should put `is_match` between ticks in the documentation
-regex-1.4.2/src/re_bytes.rs:721:13: redundant field names in struct initialization
-regex-1.4.2/src/re_bytes.rs:818:5: you should put `CaptureLocations` between ticks in the documentation
-regex-1.4.2/src/re_bytes.rs:844:1: item `re_bytes::CaptureLocations` has a public `len` method but no corresponding `is_empty` method
-regex-1.4.2/src/re_bytes.rs:850:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/re_bytes.rs:859:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/re_bytes.rs:870:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/re_bytes.rs:892:1: item `re_bytes::Captures<'t>` has a public `len` method but no corresponding `is_empty` method
-regex-1.4.2/src/re_bytes.rs:912:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/re_bytes.rs:918:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/re_bytes.rs:927:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/re_bytes.rs:961:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/re_set.rs:108:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/re_set.rs:108:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/re_set.rs:192:13: redundant field names in struct initialization
-regex-1.4.2/src/re_set.rs:192:13: redundant field names in struct initialization
-regex-1.4.2/src/re_set.rs:269:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/re_set.rs:269:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/re_set.rs:281:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/re_set.rs:281:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/re_set.rs:286:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/re_set.rs:286:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/re_set.rs:295:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/re_set.rs:295:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/re_set.rs:94:5: docs for function returning `Result` missing `# Errors` section
-regex-1.4.2/src/re_set.rs:94:5: docs for function returning `Result` missing `# Errors` section
-regex-1.4.2/src/re_trait.rs:137:29: redundant field names in struct initialization
-regex-1.4.2/src/re_unicode.rs:1025:9: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
-regex-1.4.2/src/re_unicode.rs:1047:9: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
-regex-1.4.2/src/re_unicode.rs:1095:13: redundant field names in struct initialization
-regex-1.4.2/src/re_unicode.rs:1142:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-regex-1.4.2/src/re_unicode.rs:1167:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-regex-1.4.2/src/re_unicode.rs:174:5: docs for function returning `Result` missing `# Errors` section
-regex-1.4.2/src/re_unicode.rs:21:1: this function could have a `#[must_use]` attribute
-regex-1.4.2/src/re_unicode.rs:314:13: redundant field names in struct initialization
-regex-1.4.2/src/re_unicode.rs:38:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/re_unicode.rs:44:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/re_unicode.rs:51:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/re_unicode.rs:57:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/re_unicode.rs:618:29: you should put `shortest_match` between ticks in the documentation
-regex-1.4.2/src/re_unicode.rs:632:29: you should put `is_match` between ticks in the documentation
-regex-1.4.2/src/re_unicode.rs:64:33: redundant field names in struct initialization
-regex-1.4.2/src/re_unicode.rs:64:47: redundant field names in struct initialization
-regex-1.4.2/src/re_unicode.rs:835:5: you should put `CaptureLocations` between ticks in the documentation
-regex-1.4.2/src/re_unicode.rs:861:1: item `re_unicode::CaptureLocations` has a public `len` method but no corresponding `is_empty` method
-regex-1.4.2/src/re_unicode.rs:867:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/re_unicode.rs:876:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/re_unicode.rs:887:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/re_unicode.rs:909:1: item `re_unicode::Captures<'t>` has a public `len` method but no corresponding `is_empty` method
-regex-1.4.2/src/re_unicode.rs:929:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/re_unicode.rs:935:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/re_unicode.rs:944:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/re_unicode.rs:978:5: this method could have a `#[must_use]` attribute
-regex-1.4.2/src/sparse.rs:11:37: you should put bare URLs between `<`/`>` or make a proper Markdown link
-regex-1.4.2/src/sparse.rs:16:1: item name starts with its containing module's name
-regex-1.4.2/src/utf8.rs:100:16: digits of hex or binary literal not grouped by four
-regex-1.4.2/src/utf8.rs:103:16: digits of hex or binary literal not grouped by four
-regex-1.4.2/src/utf8.rs:106:22: casting `u8` to `u32` may become silently lossy if you later change the type
-regex-1.4.2/src/utf8.rs:107:19: casting `u8` to `u32` may become silently lossy if you later change the type
-regex-1.4.2/src/utf8.rs:108:19: casting `u8` to `u32` may become silently lossy if you later change the type
-regex-1.4.2/src/utf8.rs:109:19: casting `u8` to `u32` may become silently lossy if you later change the type
-regex-1.4.2/src/utf8.rs:111:27: long literal lacking separators
-regex-1.4.2/src/utf8.rs:121:1: item name ends with its containing module's name
-regex-1.4.2/src/utf8.rs:143:24: digits of hex or binary literal not grouped by four
-regex-1.4.2/src/utf8.rs:143:9: digits of hex or binary literal not grouped by four
-regex-1.4.2/src/utf8.rs:23:1: item name ends with its containing module's name
-regex-1.4.2/src/utf8.rs:30:20: digits of hex or binary literal not grouped by four
-regex-1.4.2/src/utf8.rs:51:1: item name ends with its containing module's name
-regex-1.4.2/src/utf8.rs:58:23: digits of hex or binary literal not grouped by four
-regex-1.4.2/src/utf8.rs:58:9: digits of hex or binary literal not grouped by four
-regex-1.4.2/src/utf8.rs:63:16: digits of hex or binary literal not grouped by four
-regex-1.4.2/src/utf8.rs:66:22: casting `u8` to `u32` may become silently lossy if you later change the type
-regex-1.4.2/src/utf8.rs:66:54: casting `u8` to `u32` may become silently lossy if you later change the type
-regex-1.4.2/src/utf8.rs:77:16: digits of hex or binary literal not grouped by four
-regex-1.4.2/src/utf8.rs:80:16: digits of hex or binary literal not grouped by four
-regex-1.4.2/src/utf8.rs:83:22: casting `u8` to `u32` may become silently lossy if you later change the type
-regex-1.4.2/src/utf8.rs:84:19: casting `u8` to `u32` may become silently lossy if you later change the type
-regex-1.4.2/src/utf8.rs:85:19: casting `u8` to `u32` may become silently lossy if you later change the type
-regex-1.4.2/src/utf8.rs:92:23: digits of hex or binary literal not grouped by four
-regex-1.4.2/src/utf8.rs:92:9: digits of hex or binary literal not grouped by four
-regex-1.4.2/src/utf8.rs:97:16: digits of hex or binary literal not grouped by four
+rayon-1.5.0/src/collections/binary_heap.rs:7:5: usage of wildcard import
+rayon-1.5.0/src/collections/binary_heap.rs:8:5: usage of wildcard import
+rayon-1.5.0/src/collections/btree_map.rs:7:5: usage of wildcard import
+rayon-1.5.0/src/collections/btree_map.rs:8:5: usage of wildcard import
+rayon-1.5.0/src/collections/btree_set.rs:7:5: usage of wildcard import
+rayon-1.5.0/src/collections/btree_set.rs:8:5: usage of wildcard import
+rayon-1.5.0/src/collections/hash_map.rs:10:5: usage of wildcard import
+rayon-1.5.0/src/collections/hash_map.rs:9:5: usage of wildcard import
+rayon-1.5.0/src/collections/hash_set.rs:10:5: usage of wildcard import
+rayon-1.5.0/src/collections/hash_set.rs:9:5: usage of wildcard import
+rayon-1.5.0/src/collections/linked_list.rs:7:5: usage of wildcard import
+rayon-1.5.0/src/collections/linked_list.rs:8:5: usage of wildcard import
+rayon-1.5.0/src/collections/mod.rs:59:32: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
+rayon-1.5.0/src/collections/vec_deque.rs:8:5: usage of wildcard import
+rayon-1.5.0/src/collections/vec_deque.rs:9:5: usage of wildcard import
+rayon-1.5.0/src/compile_fail/cannot_collect_filtermap_data.rs:2:1: needless `fn main` in doctest
+rayon-1.5.0/src/compile_fail/cannot_zip_filtered_data.rs:2:1: needless `fn main` in doctest
+rayon-1.5.0/src/compile_fail/cell_par_iter.rs:2:1: needless `fn main` in doctest
+rayon-1.5.0/src/compile_fail/no_send_par_iter.rs:25:1: needless `fn main` in doctest
+rayon-1.5.0/src/compile_fail/no_send_par_iter.rs:46:1: needless `fn main` in doctest
+rayon-1.5.0/src/compile_fail/no_send_par_iter.rs:4:1: needless `fn main` in doctest
+rayon-1.5.0/src/compile_fail/rc_par_iter.rs:2:1: needless `fn main` in doctest
+rayon-1.5.0/src/iter/chain.rs:103:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/chain.rs:122:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/chain.rs:128:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/chain.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/chain.rs:221:36: you should put `ExactSizeIterator` between ticks in the documentation
+rayon-1.5.0/src/iter/chain.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/chain.rs:51:38: use Option::map_or_else instead of an if let/else
+rayon-1.5.0/src/iter/chain.rs:58:14: `a` is being shadowed
+rayon-1.5.0/src/iter/chain.rs:58:17: `b` is being shadowed
+rayon-1.5.0/src/iter/chain.rs:78:14: `a` is being shadowed
+rayon-1.5.0/src/iter/chain.rs:78:17: `b` is being shadowed
+rayon-1.5.0/src/iter/chain.rs:97:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/chunks.rs:3:5: usage of wildcard import
+rayon-1.5.0/src/iter/chunks.rs:4:5: usage of wildcard import
+rayon-1.5.0/src/iter/chunks.rs:77:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/chunks.rs:83:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/cloned.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/cloned.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/cloned.rs:71:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/cloned.rs:75:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/collect/consumer.rs:141:5: you should put `CollectReducer` between ticks in the documentation
+rayon-1.5.0/src/iter/collect/consumer.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/collect/consumer.rs:28:5: you should put `CollectResult` between ticks in the documentation
+rayon-1.5.0/src/iter/collect/consumer.rs:36:37: generally you want to avoid `&mut &mut _` if possible
+rayon-1.5.0/src/iter/collect/consumer.rs:36:37: generally you want to avoid `&mut &mut _` if possible
+rayon-1.5.0/src/iter/collect/mod.rs:154:9: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+rayon-1.5.0/src/iter/copied.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/copied.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/copied.rs:71:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/copied.rs:75:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/empty.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/empty.rs:24:1: this function could have a `#[must_use]` attribute
+rayon-1.5.0/src/iter/empty.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/enumerate.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/enumerate.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/enumerate.rs:64:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/enumerate.rs:68:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/extend.rs:143:63: I see you're using a LinkedList! Perhaps you meant some other data structure?
+rayon-1.5.0/src/iter/extend.rs:182:57: I see you're using a LinkedList! Perhaps you meant some other data structure?
+rayon-1.5.0/src/iter/extend.rs:218:32: I see you're using a LinkedList! Perhaps you meant some other data structure?
+rayon-1.5.0/src/iter/extend.rs:218:59: I see you're using a LinkedList! Perhaps you meant some other data structure?
+rayon-1.5.0/src/iter/extend.rs:25:42: I see you're using a LinkedList! Perhaps you meant some other data structure?
+rayon-1.5.0/src/iter/extend.rs:287:62: I see you're using a LinkedList! Perhaps you meant some other data structure?
+rayon-1.5.0/src/iter/extend.rs:322:56: I see you're using a LinkedList! Perhaps you meant some other data structure?
+rayon-1.5.0/src/iter/extend.rs:41:27: I see you're using a LinkedList! Perhaps you meant some other data structure?
+rayon-1.5.0/src/iter/extend.rs:47:30: I see you're using a LinkedList! Perhaps you meant some other data structure?
+rayon-1.5.0/src/iter/extend.rs:47:56: I see you're using a LinkedList! Perhaps you meant some other data structure?
+rayon-1.5.0/src/iter/extend.rs:47:74: I see you're using a LinkedList! Perhaps you meant some other data structure?
+rayon-1.5.0/src/iter/extend.rs:53:29: I see you're using a LinkedList! Perhaps you meant some other data structure?
+rayon-1.5.0/src/iter/extend.rs:57:36: I see you're using a LinkedList! Perhaps you meant some other data structure?
+rayon-1.5.0/src/iter/extend.rs:59:61: I see you're using a LinkedList! Perhaps you meant some other data structure?
+rayon-1.5.0/src/iter/filter.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/filter.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/filter_map.rs:123:9: use Option::map_or instead of an if let/else
+rayon-1.5.0/src/iter/filter_map.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/filter_map.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/find.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/find.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/find_first_last/mod.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/find_first_last/mod.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/find_first_last/mod.rs:32:67: you should put `MatchPosition` between ticks in the documentation
+rayon-1.5.0/src/iter/flat_map.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/flat_map.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/flat_map_iter.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/flat_map_iter.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/flatten.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/flatten.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/flatten_iter.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/flatten_iter.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/fold.rs:158:13: binding's name is too similar to existing binding
+rayon-1.5.0/src/iter/fold.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/fold.rs:204:1: item name starts with its containing module's name
+rayon-1.5.0/src/iter/fold.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/for_each.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/for_each.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/inspect.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/inspect.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/inspect.rs:83:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/inspect.rs:88:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/interleave.rs:111:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/interleave.rs:119:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/interleave.rs:195:30: you should put `self.i_len` between ticks in the documentation
+rayon-1.5.0/src/iter/interleave.rs:195:43: you should put `self.j_len` between ticks in the documentation
+rayon-1.5.0/src/iter/interleave.rs:199:23: you should put `self.i_len` between ticks in the documentation
+rayon-1.5.0/src/iter/interleave.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/interleave.rs:200:23: you should put `self.j_len` between ticks in the documentation
+rayon-1.5.0/src/iter/interleave.rs:249:41: you should put `DoubleEndedIterator` between ticks in the documentation
+rayon-1.5.0/src/iter/interleave.rs:250:5: you should put `ExactSizeIterator` between ticks in the documentation
+rayon-1.5.0/src/iter/interleave.rs:263:33: you should put `InterleaveSeq` between ticks in the documentation
+rayon-1.5.0/src/iter/interleave.rs:280:17: wildcard match will miss any future added variants
+rayon-1.5.0/src/iter/interleave.rs:285:17: wildcard match will miss any future added variants
+rayon-1.5.0/src/iter/interleave.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/interleave.rs:313:9: `if` chain can be rewritten with `match`
+rayon-1.5.0/src/iter/interleave.rs:82:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/interleave.rs:90:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/interleave_shortest.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/intersperse.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/intersperse.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/intersperse.rs:90:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/intersperse.rs:96:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/len.rs:12:1: item name ends with its containing module's name
+rayon-1.5.0/src/iter/len.rs:146:1: item name ends with its containing module's name
+rayon-1.5.0/src/iter/len.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/len.rs:200:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/len.rs:205:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/len.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/len.rs:66:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/len.rs:71:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/map.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/map.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/map.rs:84:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/map.rs:89:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/map_with.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/map_with.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/map_with.rs:419:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/map_with.rs:425:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/map_with.rs:90:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/map_with.rs:96:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/mod.rs:1874:24: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+rayon-1.5.0/src/iter/mod.rs:2171:1: trait `IndexedParallelIterator` has a `len` method but no (possibly inherited) `is_empty` method
+rayon-1.5.0/src/iter/mod.rs:2371:26: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+rayon-1.5.0/src/iter/mod.rs:2411:26: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+rayon-1.5.0/src/iter/mod.rs:82:5: usage of wildcard import
+rayon-1.5.0/src/iter/multizip.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/multizip.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/noop.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/once.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/once.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/panic_fuse.rs:102:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/panic_fuse.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/panic_fuse.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/panic_fuse.rs:98:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/par_bridge.rs:136:28: redundant else block
+rayon-1.5.0/src/iter/par_bridge.rs:163:28: redundant else block
+rayon-1.5.0/src/iter/plumbing/mod.rs:216:58: you should put `find_first` between ticks in the documentation
+rayon-1.5.0/src/iter/plumbing/mod.rs:359:5: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/plumbing/mod.rs:364:5: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/plumbing/mod.rs:399:5: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/plumbing/mod.rs:53:19: you should put `DoubleEndedIterator` between ticks in the documentation
+rayon-1.5.0/src/iter/plumbing/mod.rs:53:43: you should put `ExactSizeIterator` between ticks in the documentation
+rayon-1.5.0/src/iter/plumbing/mod.rs:54:31: you should put `IntoIterator` between ticks in the documentation
+rayon-1.5.0/src/iter/plumbing/mod.rs:55:5: you should put `IntoIterator` between ticks in the documentation
+rayon-1.5.0/src/iter/positions.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/positions.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/product.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/reduce.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/repeat.rs:103:1: item name starts with its containing module's name
+rayon-1.5.0/src/iter/repeat.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/repeat.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/rev.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/rev.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/rev.rs:63:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/rev.rs:68:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/skip.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/skip.rs:3:5: usage of wildcard import
+rayon-1.5.0/src/iter/skip.rs:68:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/skip.rs:73:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/splitter.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/splitter.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/step_by.rs:4:5: usage of wildcard import
+rayon-1.5.0/src/iter/step_by.rs:5:5: usage of wildcard import
+rayon-1.5.0/src/iter/step_by.rs:73:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/step_by.rs:79:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/sum.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/take.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/take.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/take.rs:67:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/take.rs:72:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/try_fold.rs:190:1: item name starts with its containing module's name
+rayon-1.5.0/src/iter/try_fold.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/try_fold.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/try_reduce.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/try_reduce_with.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/unzip.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/unzip.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/update.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/update.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/update.rs:82:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/update.rs:87:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/while_some.rs:130:22: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+rayon-1.5.0/src/iter/while_some.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/while_some.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/zip.rs:102:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/zip.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/zip.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/iter/zip.rs:74:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/zip.rs:79:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/zip.rs:97:9: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/iter/zip_eq.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/iter/zip_eq.rs:2:5: usage of wildcard import
+rayon-1.5.0/src/option.rs:8:5: usage of wildcard import
+rayon-1.5.0/src/option.rs:9:5: usage of wildcard import
+rayon-1.5.0/src/par_either.rs:1:5: usage of wildcard import
+rayon-1.5.0/src/par_either.rs:3:5: usage of wildcard import
+rayon-1.5.0/src/private.rs:9:1: item name starts with its containing module's name
+rayon-1.5.0/src/range.rs:19:5: usage of wildcard import
+rayon-1.5.0/src/range.rs:20:5: usage of wildcard import
+rayon-1.5.0/src/range_inclusive.rs:194:9: an inclusive range would be more readable
+rayon-1.5.0/src/range_inclusive.rs:194:9: an inclusive range would be more readable
+rayon-1.5.0/src/range_inclusive.rs:19:5: usage of wildcard import
+rayon-1.5.0/src/range_inclusive.rs:209:9: an inclusive range would be more readable
+rayon-1.5.0/src/range_inclusive.rs:209:9: an inclusive range would be more readable
+rayon-1.5.0/src/range_inclusive.rs:20:5: usage of wildcard import
+rayon-1.5.0/src/range_inclusive.rs:231:9: an inclusive range would be more readable
+rayon-1.5.0/src/range_inclusive.rs:231:9: an inclusive range would be more readable
+rayon-1.5.0/src/result.rs:8:5: usage of wildcard import
+rayon-1.5.0/src/result.rs:9:5: usage of wildcard import
+rayon-1.5.0/src/slice/mergesort.rs:102:5: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/slice/mergesort.rs:109:5: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/slice/mergesort.rs:114:5: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/slice/mergesort.rs:211:5: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/slice/mergesort.rs:217:5: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/slice/mergesort.rs:251:5: you should put `TimSort` between ticks in the documentation
+rayon-1.5.0/src/slice/mergesort.rs:252:5: you should put bare URLs between `<`/`>` or make a proper Markdown link
+rayon-1.5.0/src/slice/mergesort.rs:286:59: you should put `TimSort` between ticks in the documentation
+rayon-1.5.0/src/slice/mergesort.rs:333:24: redundant else block
+rayon-1.5.0/src/slice/mergesort.rs:513:5: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/slice/mergesort.rs:521:5: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/slice/mergesort.rs:7:5: usage of wildcard import
+rayon-1.5.0/src/slice/mergesort.rs:98:5: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/slice/mod.rs:15:5: usage of wildcard import
+rayon-1.5.0/src/slice/mod.rs:16:5: usage of wildcard import
+rayon-1.5.0/src/slice/mod.rs:17:5: usage of wildcard import
+rayon-1.5.0/src/slice/mod.rs:25:1: item name ends with its containing module's name
+rayon-1.5.0/src/slice/mod.rs:657:5: this method could have a `#[must_use]` attribute
+rayon-1.5.0/src/slice/mod.rs:971:5: this method could have a `#[must_use]` attribute
+rayon-1.5.0/src/slice/quicksort.rs:230:36: you should put `BlockQuicksort` between ticks in the documentation
+rayon-1.5.0/src/slice/quicksort.rs:233:1: this function has too many lines (117/100)
+rayon-1.5.0/src/slice/quicksort.rs:258:26: integer type suffix should be separated by an underscore
+rayon-1.5.0/src/slice/quicksort.rs:265:26: integer type suffix should be separated by an underscore
+rayon-1.5.0/src/slice/quicksort.rs:268:5: adding items after statements is confusing, since items exist from the start of the scope
+rayon-1.5.0/src/slice/quicksort.rs:308:30: casting `usize` to `u8` may truncate the value
+rayon-1.5.0/src/slice/quicksort.rs:325:30: casting `usize` to `u8` may truncate the value
+rayon-1.5.0/src/slice/quicksort.rs:393:36: casting `u8` to `isize` may wrap around the value on targets with 32-bit wide pointers
+rayon-1.5.0/src/slice/quicksort.rs:405:40: casting `u8` to `isize` may wrap around the value on targets with 32-bit wide pointers
+rayon-1.5.0/src/slice/quicksort.rs:430:14: `pivot` is being shadowed
+rayon-1.5.0/src/slice/quicksort.rs:439:13: `pivot` is being shadowed
+rayon-1.5.0/src/slice/quicksort.rs:482:10: `pivot` is being shadowed
+rayon-1.5.0/src/slice/quicksort.rs:491:9: `pivot` is being shadowed
+rayon-1.5.0/src/slice/quicksort.rs:534:26: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+rayon-1.5.0/src/slice/quicksort.rs:545:17: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
+rayon-1.5.0/src/slice/quicksort.rs:588:17: the operation is ineffective. Consider reducing it to `len / 4`
+rayon-1.5.0/src/slice/quicksort.rs:716:14: `pivot` is being shadowed
+rayon-1.5.0/src/split_producer.rs:56:16: use Option::map_or_else instead of an if let/else
+rayon-1.5.0/src/split_producer.rs:92:9: use Option::map_or instead of an if let/else
+rayon-1.5.0/src/str.rs:16:5: usage of wildcard import
+rayon-1.5.0/src/str.rs:17:5: usage of wildcard import
+rayon-1.5.0/src/str.rs:18:5: usage of wildcard import
+rayon-1.5.0/src/str.rs:25:5: casting `u8` to `i8` may wrap around the value
+rayon-1.5.0/src/str.rs:715:9: stripping a suffix manually
+rayon-1.5.0/src/string.rs:5:5: usage of wildcard import
+rayon-1.5.0/src/vec.rs:137:12: length comparison to zero
+rayon-1.5.0/src/vec.rs:8:5: usage of wildcard import
+rayon-1.5.0/src/vec.rs:9:5: usage of wildcard import
+regex-1.3.2/src/backtrack.rs:100:13: redundant field names in struct initialization
+regex-1.3.2/src/backtrack.rs:133:17: it looks like the same item is being pushed into this Vec
+regex-1.3.2/src/backtrack.rs:145:20: unnecessary boolean `not` operation
+regex-1.3.2/src/backtrack.rs:199:13: usage of wildcard import for enum variants
+regex-1.3.2/src/backtrack.rs:223:29: redundant field names in struct initialization
+regex-1.3.2/src/backtrack.rs:230:66: redundant field names in struct initialization
+regex-1.3.2/src/backtrack.rs:284:21: casting `u32` to `u64` may become silently lossy if you later change the type
+regex-1.3.2/src/backtrack.rs:287:5: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+regex-1.3.2/src/backtrack.rs:97:13: redundant field names in struct initialization
+regex-1.3.2/src/backtrack.rs:98:13: redundant field names in struct initialization
+regex-1.3.2/src/backtrack.rs:99:13: redundant field names in struct initialization
+regex-1.3.2/src/compile.rs:1005:32: long literal lacking separators
+regex-1.3.2/src/compile.rs:1006:21: long literal lacking separators
+regex-1.3.2/src/compile.rs:1008:18: casting `u8` to `u64` may become silently lossy if you later change the type
+regex-1.3.2/src/compile.rs:1009:18: casting `u8` to `u64` may become silently lossy if you later change the type
+regex-1.3.2/src/compile.rs:1010:9: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
+regex-1.3.2/src/compile.rs:102:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/compile.rs:1037:37: casting `u16` to `u8` may truncate the value
+regex-1.3.2/src/compile.rs:1037:55: casting `u16` to `u8` may truncate the value
+regex-1.3.2/src/compile.rs:1040:28: casting `u16` to `u8` may truncate the value
+regex-1.3.2/src/compile.rs:1040:38: casting `u16` to `u8` may truncate the value
+regex-1.3.2/src/compile.rs:1051:25: integer type suffix should be separated by an underscore
+regex-1.3.2/src/compile.rs:1071:8: casting `u32` to `u64` may become silently lossy if you later change the type
+regex-1.3.2/src/compile.rs:112:5: docs for function returning `Result` missing `# Errors` section
+regex-1.3.2/src/compile.rs:154:30: redundant closure found
+regex-1.3.2/src/compile.rs:156:30: redundant closure found
+regex-1.3.2/src/compile.rs:185:5: this function's return value is unnecessarily wrapped by `Result`
+regex-1.3.2/src/compile.rs:187:40: redundant closure found
+regex-1.3.2/src/compile.rs:201:53: you should put `MaybeInsts` between ticks in the documentation
+regex-1.3.2/src/compile.rs:241:63: you should put `c_concat` between ticks in the documentation
+regex-1.3.2/src/compile.rs:245:5: this function has too many lines (111/100)
+regex-1.3.2/src/compile.rs:247:13: usage of wildcard import for enum variants
+regex-1.3.2/src/compile.rs:373:24: redundant field names in struct initialization
+regex-1.3.2/src/compile.rs:373:36: redundant field names in struct initialization
+regex-1.3.2/src/compile.rs:378:12: unnecessary boolean `not` operation
+regex-1.3.2/src/compile.rs:400:37: redundant field names in struct initialization
+regex-1.3.2/src/compile.rs:407:51: redundant field names in struct initialization
+regex-1.3.2/src/compile.rs:409:24: redundant field names in struct initialization
+regex-1.3.2/src/compile.rs:417:5: this function's return value is unnecessarily wrapped by `Result`
+regex-1.3.2/src/compile.rs:42:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/compile.rs:42:5: you should consider adding a `Default` implementation for `compile::Compiler`
+regex-1.3.2/src/compile.rs:444:5: this function's return value is unnecessarily wrapped by `Result`
+regex-1.3.2/src/compile.rs:445:57: redundant field names in struct initialization
+regex-1.3.2/src/compile.rs:446:20: redundant field names in struct initialization
+regex-1.3.2/src/compile.rs:466:20: redundant field names in struct initialization
+regex-1.3.2/src/compile.rs:466:32: redundant field names in struct initialization
+regex-1.3.2/src/compile.rs:519:13: usage of wildcard import for enum variants
+regex-1.3.2/src/compile.rs:55:57: you should put `size_limit` between ticks in the documentation
+regex-1.3.2/src/compile.rs:58:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/compile.rs:748:41: redundant field names in struct initialization
+regex-1.3.2/src/compile.rs:74:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/compile.rs:751:54: redundant field names in struct initialization
+regex-1.3.2/src/compile.rs:765:41: redundant field names in struct initialization
+regex-1.3.2/src/compile.rs:765:55: redundant field names in struct initialization
+regex-1.3.2/src/compile.rs:825:39: redundant field names in struct initialization
+regex-1.3.2/src/compile.rs:825:51: redundant field names in struct initialization
+regex-1.3.2/src/compile.rs:828:49: redundant field names in struct initialization
+regex-1.3.2/src/compile.rs:828:61: redundant field names in struct initialization
+regex-1.3.2/src/compile.rs:830:59: redundant field names in struct initialization
+regex-1.3.2/src/compile.rs:830:71: redundant field names in struct initialization
+regex-1.3.2/src/compile.rs:832:43: redundant field names in struct initialization
+regex-1.3.2/src/compile.rs:835:41: redundant field names in struct initialization
+regex-1.3.2/src/compile.rs:835:53: redundant field names in struct initialization
+regex-1.3.2/src/compile.rs:835:67: redundant field names in struct initialization
+regex-1.3.2/src/compile.rs:83:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/compile.rs:896:5: this function's return value is unnecessarily wrapped by `Result`
+regex-1.3.2/src/compile.rs:905:17: redundant field names in struct initialization
+regex-1.3.2/src/compile.rs:953:17: you should put `HashMap` between ticks in the documentation
+regex-1.3.2/src/compile.rs:95:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/compile.rs:980:26: integer type suffix should be separated by an underscore
+regex-1.3.2/src/compile.rs:994:44: redundant field names in struct initialization
+regex-1.3.2/src/compile.rs:994:54: redundant field names in struct initialization
+regex-1.3.2/src/dfa.rs:1007:17: binding's name is too similar to existing binding
+regex-1.3.2/src/dfa.rs:1010:22: binding's name is too similar to existing binding
+regex-1.3.2/src/dfa.rs:1059:13: usage of wildcard import for enum variants
+regex-1.3.2/src/dfa.rs:1060:13: usage of wildcard import for enum variants
+regex-1.3.2/src/dfa.rs:1084:38: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+regex-1.3.2/src/dfa.rs:1087:38: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+regex-1.3.2/src/dfa.rs:1090:38: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+regex-1.3.2/src/dfa.rs:1093:38: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+regex-1.3.2/src/dfa.rs:1096:38: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+regex-1.3.2/src/dfa.rs:1101:38: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+regex-1.3.2/src/dfa.rs:1104:38: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+regex-1.3.2/src/dfa.rs:1107:38: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+regex-1.3.2/src/dfa.rs:1117:30: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+regex-1.3.2/src/dfa.rs:1120:47: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+regex-1.3.2/src/dfa.rs:1121:30: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+regex-1.3.2/src/dfa.rs:1129:13: you should put `is_match` between ticks in the documentation
+regex-1.3.2/src/dfa.rs:1134:13: you should put `is_match` between ticks in the documentation
+regex-1.3.2/src/dfa.rs:1185:68: you should put `is_match` between ticks in the documentation
+regex-1.3.2/src/dfa.rs:1193:13: usage of wildcard import for enum variants
+regex-1.3.2/src/dfa.rs:1244:50: you should put `current_state` between ticks in the documentation
+regex-1.3.2/src/dfa.rs:1338:58: you should put `STATE_DEAD` between ticks in the documentation
+regex-1.3.2/src/dfa.rs:1339:9: you should put `STATE_UNKNOWN` between ticks in the documentation
+regex-1.3.2/src/dfa.rs:1366:25: you should put `STATE_DEAD` between ticks in the documentation
+regex-1.3.2/src/dfa.rs:1366:46: you should put `STATE_UNKNOWN` between ticks in the documentation
+regex-1.3.2/src/dfa.rs:1367:41: you have declared `#[inline(always)]` on `start_state`. This is usually a bad idea
+regex-1.3.2/src/dfa.rs:1380:14: the operation is ineffective. Consider reducing it to `(empty_flags.start as u8)`
+regex-1.3.2/src/dfa.rs:1388:15: indexing into a vector may panic
+regex-1.3.2/src/dfa.rs:1412:20: unused `self` argument
+regex-1.3.2/src/dfa.rs:1438:9: unused `self` argument
+regex-1.3.2/src/dfa.rs:1472:9: you should put `StatePtr` between ticks in the documentation
+regex-1.3.2/src/dfa.rs:1490:54: casting `i32` to `u8` may lose the sign of the value
+regex-1.3.2/src/dfa.rs:1490:54: casting `i32` to `u8` may truncate the value
+regex-1.3.2/src/dfa.rs:1521:20: you should put `num_byte_classes` between ticks in the documentation
+regex-1.3.2/src/dfa.rs:1529:41: you have declared `#[inline(always)]` on `byte_class`. This is usually a bad idea
+regex-1.3.2/src/dfa.rs:1537:14: you should put `byte_class` between ticks in the documentation
+regex-1.3.2/src/dfa.rs:1538:41: you have declared `#[inline(always)]` on `u8_class`. This is usually a bad idea
+regex-1.3.2/src/dfa.rs:1562:18: you should put `STATE_START` between ticks in the documentation
+regex-1.3.2/src/dfa.rs:1614:13: redundant field names in struct initialization
+regex-1.3.2/src/dfa.rs:1651:38: redundant field names in struct initialization
+regex-1.3.2/src/dfa.rs:1700:17: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+regex-1.3.2/src/dfa.rs:1701:18: digits of hex or binary literal not grouped by four
+regex-1.3.2/src/dfa.rs:1705:19: digits of hex or binary literal not grouped by four
+regex-1.3.2/src/dfa.rs:1708:16: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+regex-1.3.2/src/dfa.rs:1709:18: digits of hex or binary literal not grouped by four
+regex-1.3.2/src/dfa.rs:1713:19: digits of hex or binary literal not grouped by four
+regex-1.3.2/src/dfa.rs:1716:18: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+regex-1.3.2/src/dfa.rs:1717:18: digits of hex or binary literal not grouped by four
+regex-1.3.2/src/dfa.rs:1721:19: digits of hex or binary literal not grouped by four
+regex-1.3.2/src/dfa.rs:1727:14: casting `u8` to `u16` may become silently lossy if you later change the type
+regex-1.3.2/src/dfa.rs:1732:15: this argument (2 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+regex-1.3.2/src/dfa.rs:1736:22: this argument (2 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+regex-1.3.2/src/dfa.rs:1741:9: match expression looks like `matches!` macro
+regex-1.3.2/src/dfa.rs:1747:16: this argument (2 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+regex-1.3.2/src/dfa.rs:1751:18: casting `u16` to `u8` may truncate the value
+regex-1.3.2/src/dfa.rs:1815:38: casting `usize` to `u8` may truncate the value
+regex-1.3.2/src/dfa.rs:1821:21: casting `u32` to `u64` may become silently lossy if you later change the type
+regex-1.3.2/src/dfa.rs:1824:5: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+regex-1.3.2/src/dfa.rs:1848:5: you should put bare URLs between `<`/`>` or make a proper Markdown link
+regex-1.3.2/src/dfa.rs:1850:18: casting `i32` to `u32` may lose the sign of the value
+regex-1.3.2/src/dfa.rs:1857:5: you should put bare URLs between `<`/`>` or make a proper Markdown link
+regex-1.3.2/src/dfa.rs:1860:17: casting `u32` to `i32` may wrap around the value
+regex-1.3.2/src/dfa.rs:1867:5: you should put bare URLs between `<`/`>` or make a proper Markdown link
+regex-1.3.2/src/dfa.rs:1870:19: casting `u32` to `u8` may truncate the value
+regex-1.3.2/src/dfa.rs:1873:15: casting `u32` to `u8` may truncate the value
+regex-1.3.2/src/dfa.rs:1876:5: you should put bare URLs between `<`/`>` or make a proper Markdown link
+regex-1.3.2/src/dfa.rs:1882:26: casting `u8` to `u32` may become silently lossy if you later change the type
+regex-1.3.2/src/dfa.rs:1884:15: casting `u8` to `u32` may become silently lossy if you later change the type
+regex-1.3.2/src/dfa.rs:277:17: casting `u32` to `i32` may wrap around the value
+regex-1.3.2/src/dfa.rs:277:31: casting `u32` to `i32` may wrap around the value
+regex-1.3.2/src/dfa.rs:295:20: casting `usize` to `i32` may truncate the value on targets with 64-bit wide pointers
+regex-1.3.2/src/dfa.rs:295:20: casting `usize` to `i32` may wrap around the value on targets with 32-bit wide pointers
+regex-1.3.2/src/dfa.rs:299:21: casting `i32` to `usize` may lose the sign of the value
+regex-1.3.2/src/dfa.rs:34:46: you should put bare URLs between `<`/`>` or make a proper Markdown link
+regex-1.3.2/src/dfa.rs:398:1: more than 3 bools in a struct
+regex-1.3.2/src/dfa.rs:446:41: you have declared `#[inline(always)]` on `forward`. This is usually a bad idea
+regex-1.3.2/src/dfa.rs:457:13: redundant field names in struct initialization
+regex-1.3.2/src/dfa.rs:459:13: redundant field names in struct initialization
+regex-1.3.2/src/dfa.rs:460:13: redundant field names in struct initialization
+regex-1.3.2/src/dfa.rs:476:41: you have declared `#[inline(always)]` on `reverse`. This is usually a bad idea
+regex-1.3.2/src/dfa.rs:487:13: redundant field names in struct initialization
+regex-1.3.2/src/dfa.rs:489:13: redundant field names in struct initialization
+regex-1.3.2/src/dfa.rs:490:13: redundant field names in struct initialization
+regex-1.3.2/src/dfa.rs:506:41: you have declared `#[inline(always)]` on `forward_many`. This is usually a bad idea
+regex-1.3.2/src/dfa.rs:518:13: redundant field names in struct initialization
+regex-1.3.2/src/dfa.rs:520:13: redundant field names in struct initialization
+regex-1.3.2/src/dfa.rs:554:41: you have declared `#[inline(always)]` on `exec_at`. This is usually a bad idea
+regex-1.3.2/src/dfa.rs:555:5: this function has too many lines (101/100)
+regex-1.3.2/src/dfa.rs:58:9: usage of wildcard import for enum variants
+regex-1.3.2/src/dfa.rs:667:21: binding's name is too similar to existing binding
+regex-1.3.2/src/dfa.rs:747:41: you have declared `#[inline(always)]` on `exec_at_reverse`. This is usually a bad idea
+regex-1.3.2/src/dfa.rs:795:21: binding's name is too similar to existing binding
+regex-1.3.2/src/dfa.rs:848:9: you should put `next_si` between ticks in the documentation
+regex-1.3.2/src/dfa.rs:852:41: you have declared `#[inline(always)]` on `next_si`. This is usually a bad idea
+regex-1.3.2/src/dfa.rs:885:12: you should put `STATE_DEAD` between ticks in the documentation
+regex-1.3.2/src/dfa.rs:889:9: you should put `STATE_UNKNOWN` between ticks in the documentation
+regex-1.3.2/src/dfa.rs:897:13: usage of wildcard import for enum variants
+regex-1.3.2/src/dfa.rs:979:29: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
+regex-1.3.2/src/error.rs:6:1: this seems like a manual implementation of the non-exhaustive pattern
+regex-1.3.2/src/exec.rs:1000:14: you should put `captures_nfa` between ticks in the documentation
+regex-1.3.2/src/exec.rs:100:1: item name starts with its containing module's name
+regex-1.3.2/src/exec.rs:1028:5: this function has too many arguments (9/7)
+regex-1.3.2/src/exec.rs:1039:13: usage of wildcard import for enum variants
+regex-1.3.2/src/exec.rs:1144:13: usage of wildcard import for enum variants
+regex-1.3.2/src/exec.rs:1179:26: this `match` has identical arm bodies
+regex-1.3.2/src/exec.rs:122:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/exec.rs:1250:41: you have declared `#[inline(always)]` on `searcher`. This is usually a bad idea
+regex-1.3.2/src/exec.rs:1260:41: you have declared `#[inline(always)]` on `searcher_str`. This is usually a bad idea
+regex-1.3.2/src/exec.rs:1270:17: you should put `RegexSet` between ticks in the documentation
+regex-1.3.2/src/exec.rs:1280:17: you should put `RegexSet` between ticks in the documentation
+regex-1.3.2/src/exec.rs:137:9: field assignment outside of initializer for an instance created with Default::default()
+regex-1.3.2/src/exec.rs:142:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/exec.rs:158:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/exec.rs:168:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/exec.rs:181:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/exec.rs:195:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/exec.rs:204:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/exec.rs:210:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/exec.rs:245:62: this `if` has identical blocks
+regex-1.3.2/src/exec.rs:251:21: unnecessary boolean `not` operation
+regex-1.3.2/src/exec.rs:262:60: this `if` has identical blocks
+regex-1.3.2/src/exec.rs:268:21: unnecessary boolean `not` operation
+regex-1.3.2/src/exec.rs:278:13: redundant field names in struct initialization
+regex-1.3.2/src/exec.rs:281:13: redundant field names in struct initialization
+regex-1.3.2/src/exec.rs:286:5: docs for function returning `Result` missing `# Errors` section
+regex-1.3.2/src/exec.rs:300:30: redundant field names in struct initialization
+regex-1.3.2/src/exec.rs:308:17: binding's name is too similar to existing binding
+regex-1.3.2/src/exec.rs:329:13: redundant field names in struct initialization
+regex-1.3.2/src/exec.rs:330:13: redundant field names in struct initialization
+regex-1.3.2/src/exec.rs:331:13: redundant field names in struct initialization
+regex-1.3.2/src/exec.rs:334:13: redundant field names in struct initialization
+regex-1.3.2/src/exec.rs:340:19: redundant field names in struct initialization
+regex-1.3.2/src/exec.rs:344:27: unused `self` argument
+regex-1.3.2/src/exec.rs:383:41: you have declared `#[inline(always)]` on `shortest_match_at`. This is usually a bad idea
+regex-1.3.2/src/exec.rs:388:41: you have declared `#[inline(always)]` on `is_match_at`. This is usually a bad idea
+regex-1.3.2/src/exec.rs:393:41: you have declared `#[inline(always)]` on `find_at`. This is usually a bad idea
+regex-1.3.2/src/exec.rs:398:41: you have declared `#[inline(always)]` on `captures_read_at`. This is usually a bad idea
+regex-1.3.2/src/exec.rs:425:41: you have declared `#[inline(always)]` on `shortest_match_at`. This is usually a bad idea
+regex-1.3.2/src/exec.rs:44:1: item name starts with its containing module's name
+regex-1.3.2/src/exec.rs:473:9: you should put `shortest_match(...).is_some` between ticks in the documentation
+regex-1.3.2/src/exec.rs:474:41: you have declared `#[inline(always)]` on `is_match_at`. This is usually a bad idea
+regex-1.3.2/src/exec.rs:524:41: you have declared `#[inline(always)]` on `find_at`. This is usually a bad idea
+regex-1.3.2/src/exec.rs:52:1: item name starts with its containing module's name
+regex-1.3.2/src/exec.rs:686:13: usage of wildcard import for enum variants
+regex-1.3.2/src/exec.rs:727:13: usage of wildcard import for enum variants
+regex-1.3.2/src/exec.rs:767:13: usage of wildcard import for enum variants
+regex-1.3.2/src/exec.rs:783:41: you have declared `#[inline(always)]` on `shortest_dfa`. This is usually a bad idea
+regex-1.3.2/src/exec.rs:791:41: you have declared `#[inline(always)]` on `shortest_dfa_reverse_suffix`. This is usually a bad idea
+regex-1.3.2/src/exec.rs:823:13: usage of wildcard import for enum variants
+regex-1.3.2/src/exec.rs:868:13: usage of wildcard import for enum variants
+regex-1.3.2/src/exec.rs:897:31: you should put `shortest_nfa(...).is_some` between ticks in the documentation
+regex-1.3.2/src/exec.rs:899:9: you should put `shortest_nfa` between ticks in the documentation
+regex-1.3.2/src/exec.rs:905:14: you should put `match_nfa` between ticks in the documentation
+regex-1.3.2/src/exec.rs:930:14: you should put `shortest_nfa` between ticks in the documentation
+regex-1.3.2/src/exec.rs:981:14: you should put `find_nfa` between ticks in the documentation
+regex-1.3.2/src/expand.rs:170:27: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+regex-1.3.2/src/expand.rs:171:5: match expression looks like `matches!` macro
+regex-1.3.2/src/expand.rs:22:13: calling `push_str()` using a single-character string literal
+regex-1.3.2/src/expand.rs:27:23: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+regex-1.3.2/src/expand.rs:30:17: calling `push_str()` using a single-character string literal
+regex-1.3.2/src/expand.rs:38:30: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
+regex-1.3.2/src/expand.rs:42:21: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
+regex-1.3.2/src/expand.rs:50:1: item name starts with its containing module's name
+regex-1.3.2/src/expand.rs:69:23: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+regex-1.3.2/src/expand.rs:80:28: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
+regex-1.3.2/src/expand.rs:84:21: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
+regex-1.3.2/src/expand.rs:8:1: item name starts with its containing module's name
+regex-1.3.2/src/input.rs:142:1: item name ends with its containing module's name
+regex-1.3.2/src/input.rs:146:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/input.rs:15:1: item name starts with its containing module's name
+regex-1.3.2/src/input.rs:165:31: redundant field names in struct initialization
+regex-1.3.2/src/input.rs:178:13: usage of wildcard import for enum variants
+regex-1.3.2/src/input.rs:228:1: item name ends with its containing module's name
+regex-1.3.2/src/input.rs:236:21: redundant field names in struct initialization
+regex-1.3.2/src/input.rs:236:33: redundant field names in struct initialization
+regex-1.3.2/src/input.rs:24:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/input.rs:271:13: usage of wildcard import for enum variants
+regex-1.3.2/src/input.rs:29:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/input.rs:362:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/input.rs:370:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/input.rs:371:42: redundant closure found
+regex-1.3.2/src/input.rs:37:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/input.rs:388:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/input.rs:42:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/input.rs:47:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/input.rs:53:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/input.rs:58:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/input.rs:63:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/literal/imp.rs:101:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/literal/imp.rs:114:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/literal/imp.rs:127:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/literal/imp.rs:139:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/literal/imp.rs:144:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/literal/imp.rs:149:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/literal/imp.rs:154:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/literal/imp.rs:155:13: usage of wildcard import for enum variants
+regex-1.3.2/src/literal/imp.rs:160:30: this `match` has identical arm bodies
+regex-1.3.2/src/literal/imp.rs:167:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/literal/imp.rs:168:13: usage of wildcard import for enum variants
+regex-1.3.2/src/literal/imp.rs:211:20: redundant else block
+regex-1.3.2/src/literal/imp.rs:276:50: this `match` has identical arm bodies
+regex-1.3.2/src/literal/imp.rs:342:41: you have declared `#[inline(always)]` on `find`. This is usually a bad idea
+regex-1.3.2/src/literal/imp.rs:435:13: redundant field names in struct initialization
+regex-1.3.2/src/literal/imp.rs:436:13: redundant field names in struct initialization
+regex-1.3.2/src/literal/imp.rs:437:13: redundant field names in struct initialization
+regex-1.3.2/src/literal/imp.rs:438:13: redundant field names in struct initialization
+regex-1.3.2/src/literal/imp.rs:439:13: redundant field names in struct initialization
+regex-1.3.2/src/literal/imp.rs:440:13: redundant field names in struct initialization
+regex-1.3.2/src/literal/imp.rs:455:41: you have declared `#[inline(always)]` on `find`. This is usually a bad idea
+regex-1.3.2/src/literal/imp.rs:46:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/literal/imp.rs:481:41: you have declared `#[inline(always)]` on `is_suffix`. This is usually a bad idea
+regex-1.3.2/src/literal/imp.rs:51:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/literal/imp.rs:579:13: redundant field names in struct initialization
+regex-1.3.2/src/literal/imp.rs:57:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/literal/imp.rs:580:13: redundant field names in struct initialization
+regex-1.3.2/src/literal/imp.rs:583:13: redundant field names in struct initialization
+regex-1.3.2/src/literal/imp.rs:602:9: adding items after statements is confusing, since items exist from the start of the scope
+regex-1.3.2/src/literal/imp.rs:622:24: redundant else block
+regex-1.3.2/src/literal/imp.rs:62:18: this argument is passed by value, but not consumed in the function body
+regex-1.3.2/src/literal/imp.rs:637:24: redundant else block
+regex-1.3.2/src/literal/imp.rs:648:9: unneeded `return` statement
+regex-1.3.2/src/literal/imp.rs:651:44: you should put `BoyerMooreSearch` between ticks in the documentation
+regex-1.3.2/src/literal/imp.rs:65:13: redundant field names in struct initialization
+regex-1.3.2/src/literal/imp.rs:68:13: redundant field names in struct initialization
+regex-1.3.2/src/literal/imp.rs:783:32: redundant else block
+regex-1.3.2/src/literal/imp.rs:786:42: manual saturating arithmetic
+regex-1.3.2/src/literal/imp.rs:78:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/literal/imp.rs:84:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/literal/imp.rs:850:20: long literal lacking separators
+regex-1.3.2/src/literal/imp.rs:85:13: usage of wildcard import for enum variants
+regex-1.3.2/src/pikevm.rs:103:15: redundant field names in struct initialization
+regex-1.3.2/src/pikevm.rs:103:52: redundant field names in struct initialization
+regex-1.3.2/src/pikevm.rs:114:5: this function has too many arguments (8/7)
+regex-1.3.2/src/pikevm.rs:117:13: binding's name is too similar to existing binding
+regex-1.3.2/src/pikevm.rs:124:17: binding's name is too similar to existing binding
+regex-1.3.2/src/pikevm.rs:220:9: you should put `thread_caps` between ticks in the documentation
+regex-1.3.2/src/pikevm.rs:222:16: you should put `at_next` between ticks in the documentation
+regex-1.3.2/src/pikevm.rs:223:9: you should put `at_next` between ticks in the documentation
+regex-1.3.2/src/pikevm.rs:224:5: this function has too many arguments (8/7)
+regex-1.3.2/src/pikevm.rs:234:13: usage of wildcard import for enum variants
+regex-1.3.2/src/pikevm.rs:303:13: usage of wildcard import for enum variants
+regex-1.3.2/src/pikevm.rs:331:29: this expression mutably borrows a mutable reference. Consider reborrowing
+regex-1.3.2/src/pikevm.rs:88:5: this function has too many arguments (8/7)
+regex-1.3.2/src/prog.rs:102:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/prog.rs:113:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/prog.rs:120:9: match expression looks like `matches!` macro
+regex-1.3.2/src/prog.rs:128:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/prog.rs:134:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/prog.rs:141:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/prog.rs:147:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/prog.rs:164:41: you have declared `#[inline(always)]` on `deref`. This is usually a bad idea
+regex-1.3.2/src/prog.rs:172:13: usage of wildcard import for enum variants
+regex-1.3.2/src/prog.rs:18:1: more than 3 bools in a struct
+regex-1.3.2/src/prog.rs:236:13: using `write!()` with a format string that ends in a single newline
+regex-1.3.2/src/prog.rs:300:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/prog.rs:301:9: match expression looks like `matches!` macro
+regex-1.3.2/src/prog.rs:382:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/prog.rs:409:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/prog.rs:80:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/prog.rs:80:5: you should consider adding a `Default` implementation for `prog::Program`
+regex-1.3.2/src/re_builder.rs:267:17: docs for function returning `Result` missing `# Errors` section
+regex-1.3.2/src/re_builder.rs:267:17: docs for function returning `Result` missing `# Errors` section
+regex-1.3.2/src/re_builder.rs:4:1: more than 3 bools in a struct
+regex-1.3.2/src/re_builder.rs:57:17: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/re_builder.rs:57:17: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/re_builder.rs:68:17: docs for function returning `Result` missing `# Errors` section
+regex-1.3.2/src/re_builder.rs:68:17: docs for function returning `Result` missing `# Errors` section
+regex-1.3.2/src/re_bytes.rs:1017:9: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
+regex-1.3.2/src/re_bytes.rs:1039:9: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
+regex-1.3.2/src/re_bytes.rs:1093:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+regex-1.3.2/src/re_bytes.rs:1118:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+regex-1.3.2/src/re_bytes.rs:1133:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+regex-1.3.2/src/re_bytes.rs:118:5: docs for function returning `Result` missing `# Errors` section
+regex-1.3.2/src/re_bytes.rs:256:13: redundant field names in struct initialization
+regex-1.3.2/src/re_bytes.rs:29:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/re_bytes.rs:35:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/re_bytes.rs:42:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/re_bytes.rs:48:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/re_bytes.rs:558:29: you should put `shortest_match` between ticks in the documentation
+regex-1.3.2/src/re_bytes.rs:55:33: redundant field names in struct initialization
+regex-1.3.2/src/re_bytes.rs:55:47: redundant field names in struct initialization
+regex-1.3.2/src/re_bytes.rs:572:29: you should put `is_match` between ticks in the documentation
+regex-1.3.2/src/re_bytes.rs:720:13: redundant field names in struct initialization
+regex-1.3.2/src/re_bytes.rs:817:5: you should put `CaptureLocations` between ticks in the documentation
+regex-1.3.2/src/re_bytes.rs:843:1: item `re_bytes::CaptureLocations` has a public `len` method but no corresponding `is_empty` method
+regex-1.3.2/src/re_bytes.rs:849:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/re_bytes.rs:858:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/re_bytes.rs:869:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/re_bytes.rs:891:1: item `re_bytes::Captures<'t>` has a public `len` method but no corresponding `is_empty` method
+regex-1.3.2/src/re_bytes.rs:911:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/re_bytes.rs:917:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/re_bytes.rs:926:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/re_bytes.rs:955:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/re_set.rs:179:13: redundant field names in struct initialization
+regex-1.3.2/src/re_set.rs:179:13: redundant field names in struct initialization
+regex-1.3.2/src/re_set.rs:251:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/re_set.rs:251:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/re_set.rs:263:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/re_set.rs:263:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/re_set.rs:268:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/re_set.rs:268:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/re_set.rs:277:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/re_set.rs:277:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/re_set.rs:94:5: docs for function returning `Result` missing `# Errors` section
+regex-1.3.2/src/re_set.rs:94:5: docs for function returning `Result` missing `# Errors` section
+regex-1.3.2/src/re_trait.rs:136:29: redundant field names in struct initialization
+regex-1.3.2/src/re_unicode.rs:1019:9: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
+regex-1.3.2/src/re_unicode.rs:1041:9: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
+regex-1.3.2/src/re_unicode.rs:1088:13: redundant field names in struct initialization
+regex-1.3.2/src/re_unicode.rs:1135:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+regex-1.3.2/src/re_unicode.rs:1160:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+regex-1.3.2/src/re_unicode.rs:174:5: docs for function returning `Result` missing `# Errors` section
+regex-1.3.2/src/re_unicode.rs:21:1: this function could have a `#[must_use]` attribute
+regex-1.3.2/src/re_unicode.rs:313:13: redundant field names in struct initialization
+regex-1.3.2/src/re_unicode.rs:38:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/re_unicode.rs:44:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/re_unicode.rs:51:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/re_unicode.rs:57:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/re_unicode.rs:617:29: you should put `shortest_match` between ticks in the documentation
+regex-1.3.2/src/re_unicode.rs:631:29: you should put `is_match` between ticks in the documentation
+regex-1.3.2/src/re_unicode.rs:64:33: redundant field names in struct initialization
+regex-1.3.2/src/re_unicode.rs:64:47: redundant field names in struct initialization
+regex-1.3.2/src/re_unicode.rs:834:5: you should put `CaptureLocations` between ticks in the documentation
+regex-1.3.2/src/re_unicode.rs:860:1: item `re_unicode::CaptureLocations` has a public `len` method but no corresponding `is_empty` method
+regex-1.3.2/src/re_unicode.rs:866:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/re_unicode.rs:875:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/re_unicode.rs:886:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/re_unicode.rs:908:1: item `re_unicode::Captures<'t>` has a public `len` method but no corresponding `is_empty` method
+regex-1.3.2/src/re_unicode.rs:928:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/re_unicode.rs:934:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/re_unicode.rs:943:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/re_unicode.rs:972:5: this method could have a `#[must_use]` attribute
+regex-1.3.2/src/sparse.rs:10:37: you should put bare URLs between `<`/`>` or make a proper Markdown link
+regex-1.3.2/src/sparse.rs:15:1: item name starts with its containing module's name
+regex-1.3.2/src/utf8.rs:100:16: digits of hex or binary literal not grouped by four
+regex-1.3.2/src/utf8.rs:103:16: digits of hex or binary literal not grouped by four
+regex-1.3.2/src/utf8.rs:106:22: casting `u8` to `u32` may become silently lossy if you later change the type
+regex-1.3.2/src/utf8.rs:107:19: casting `u8` to `u32` may become silently lossy if you later change the type
+regex-1.3.2/src/utf8.rs:108:19: casting `u8` to `u32` may become silently lossy if you later change the type
+regex-1.3.2/src/utf8.rs:109:19: casting `u8` to `u32` may become silently lossy if you later change the type
+regex-1.3.2/src/utf8.rs:111:27: long literal lacking separators
+regex-1.3.2/src/utf8.rs:121:1: item name ends with its containing module's name
+regex-1.3.2/src/utf8.rs:143:24: digits of hex or binary literal not grouped by four
+regex-1.3.2/src/utf8.rs:143:9: digits of hex or binary literal not grouped by four
+regex-1.3.2/src/utf8.rs:23:1: item name ends with its containing module's name
+regex-1.3.2/src/utf8.rs:30:20: digits of hex or binary literal not grouped by four
+regex-1.3.2/src/utf8.rs:51:1: item name ends with its containing module's name
+regex-1.3.2/src/utf8.rs:58:23: digits of hex or binary literal not grouped by four
+regex-1.3.2/src/utf8.rs:58:9: digits of hex or binary literal not grouped by four
+regex-1.3.2/src/utf8.rs:63:16: digits of hex or binary literal not grouped by four
+regex-1.3.2/src/utf8.rs:66:22: casting `u8` to `u32` may become silently lossy if you later change the type
+regex-1.3.2/src/utf8.rs:66:54: casting `u8` to `u32` may become silently lossy if you later change the type
+regex-1.3.2/src/utf8.rs:77:16: digits of hex or binary literal not grouped by four
+regex-1.3.2/src/utf8.rs:80:16: digits of hex or binary literal not grouped by four
+regex-1.3.2/src/utf8.rs:83:22: casting `u8` to `u32` may become silently lossy if you later change the type
+regex-1.3.2/src/utf8.rs:84:19: casting `u8` to `u32` may become silently lossy if you later change the type
+regex-1.3.2/src/utf8.rs:85:19: casting `u8` to `u32` may become silently lossy if you later change the type
+regex-1.3.2/src/utf8.rs:92:23: digits of hex or binary literal not grouped by four
+regex-1.3.2/src/utf8.rs:92:9: digits of hex or binary literal not grouped by four
+regex-1.3.2/src/utf8.rs:97:16: digits of hex or binary literal not grouped by four
+ripgrep-12.1.1/build.rs:133:19: called `.as_ref().map(|x| &**x)` on an Option value. This can be done more directly by calling `githash.as_deref()` instead
+ripgrep-12.1.1/build.rs:18:18: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+ripgrep-12.1.1/build.rs:225:14: redundant closure found
+ripgrep-12.1.1/build.rs:92:19: called `.as_ref().map(|x| &**x)` on an Option value. This can be done more directly by calling `githash.as_deref()` instead
+ripgrep-12.1.1/crates/core/app.rs:1408:5: adding items after statements is confusing, since items exist from the start of the scope
+ripgrep-12.1.1/crates/core/app.rs:1408:5: adding items after statements is confusing, since items exist from the start of the scope
+ripgrep-12.1.1/crates/core/app.rs:1409:5: adding items after statements is confusing, since items exist from the start of the scope
+ripgrep-12.1.1/crates/core/app.rs:1409:5: adding items after statements is confusing, since items exist from the start of the scope
+ripgrep-12.1.1/crates/core/app.rs:152:32: you should put `clap::Arg` between ticks in the documentation
+ripgrep-12.1.1/crates/core/app.rs:152:32: you should put `clap::Arg` between ticks in the documentation
+ripgrep-12.1.1/crates/core/app.rs:156:39: you should put `clap::Arg` between ticks in the documentation
+ripgrep-12.1.1/crates/core/app.rs:156:39: you should put `clap::Arg` between ticks in the documentation
+ripgrep-12.1.1/crates/core/app.rs:156:5: you should put `RGArg` between ticks in the documentation
+ripgrep-12.1.1/crates/core/app.rs:156:5: you should put `RGArg` between ticks in the documentation
+ripgrep-12.1.1/crates/core/app.rs:1668:5: adding items after statements is confusing, since items exist from the start of the scope
+ripgrep-12.1.1/crates/core/app.rs:1668:5: adding items after statements is confusing, since items exist from the start of the scope
+ripgrep-12.1.1/crates/core/app.rs:1669:5: adding items after statements is confusing, since items exist from the start of the scope
+ripgrep-12.1.1/crates/core/app.rs:1669:5: adding items after statements is confusing, since items exist from the start of the scope
+ripgrep-12.1.1/crates/core/app.rs:1821:5: adding items after statements is confusing, since items exist from the start of the scope
+ripgrep-12.1.1/crates/core/app.rs:1821:5: adding items after statements is confusing, since items exist from the start of the scope
+ripgrep-12.1.1/crates/core/app.rs:1822:5: adding items after statements is confusing, since items exist from the start of the scope
+ripgrep-12.1.1/crates/core/app.rs:1822:5: adding items after statements is confusing, since items exist from the start of the scope
+ripgrep-12.1.1/crates/core/app.rs:2999:5: adding items after statements is confusing, since items exist from the start of the scope
+ripgrep-12.1.1/crates/core/app.rs:2999:5: adding items after statements is confusing, since items exist from the start of the scope
+ripgrep-12.1.1/crates/core/app.rs:3000:5: adding items after statements is confusing, since items exist from the start of the scope
+ripgrep-12.1.1/crates/core/app.rs:3000:5: adding items after statements is confusing, since items exist from the start of the scope
+ripgrep-12.1.1/crates/core/app.rs:367:54: this `match` has identical arm bodies
+ripgrep-12.1.1/crates/core/app.rs:367:54: this `match` has identical arm bodies
+ripgrep-12.1.1/crates/core/app.rs:414:59: this `match` has identical arm bodies
+ripgrep-12.1.1/crates/core/app.rs:414:59: this `match` has identical arm bodies
+ripgrep-12.1.1/crates/core/app.rs:417:57: this `match` has identical arm bodies
+ripgrep-12.1.1/crates/core/app.rs:417:57: this `match` has identical arm bodies
+ripgrep-12.1.1/crates/core/app.rs:417:57: this `match` has identical arm bodies
+ripgrep-12.1.1/crates/core/app.rs:417:57: this `match` has identical arm bodies
+ripgrep-12.1.1/crates/core/app.rs:444:41: this `match` has identical arm bodies
+ripgrep-12.1.1/crates/core/app.rs:444:41: this `match` has identical arm bodies
+ripgrep-12.1.1/crates/core/app.rs:470:41: this `match` has identical arm bodies
+ripgrep-12.1.1/crates/core/app.rs:470:41: this `match` has identical arm bodies
+ripgrep-12.1.1/crates/core/app.rs:75:9: you should put `RIPGREP_BUILD_GIT_HASH` between ticks in the documentation
+ripgrep-12.1.1/crates/core/app.rs:75:9: you should put `RIPGREP_BUILD_GIT_HASH` between ticks in the documentation
+ripgrep-12.1.1/crates/core/app.rs:87:5: unnecessary boolean `not` operation
+ripgrep-12.1.1/crates/core/app.rs:87:5: unnecessary boolean `not` operation
+ripgrep-12.1.1/crates/core/args.rs:1143:22: unused `self` argument
+ripgrep-12.1.1/crates/core/args.rs:11:1: this import is redundant
+ripgrep-12.1.1/crates/core/args.rs:1209:74: this `if` has identical blocks
+ripgrep-12.1.1/crates/core/args.rs:1209:74: this `if` has identical blocks
+ripgrep-12.1.1/crates/core/args.rs:1282:13: binding's name is too similar to existing binding
+ripgrep-12.1.1/crates/core/args.rs:1430:22: unused `self` argument
+ripgrep-12.1.1/crates/core/args.rs:1438:21: you should put `OsStr` between ticks in the documentation
+ripgrep-12.1.1/crates/core/args.rs:1520:44: redundant closure found
+ripgrep-12.1.1/crates/core/args.rs:1524:5: this function's return value is unnecessarily wrapped by `Result`
+ripgrep-12.1.1/crates/core/args.rs:1635:14: you should put `values_of_lossy` between ticks in the documentation
+ripgrep-12.1.1/crates/core/args.rs:1693:41: redundant closure found
+ripgrep-12.1.1/crates/core/args.rs:1770:17: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
+ripgrep-12.1.1/crates/core/args.rs:287:13: binding's name is too similar to existing binding
+ripgrep-12.1.1/crates/core/args.rs:33:1: this import is redundant
+ripgrep-12.1.1/crates/core/args.rs:34:1: this import is redundant
+ripgrep-12.1.1/crates/core/args.rs:35:1: this import is redundant
+ripgrep-12.1.1/crates/core/args.rs:410:14: this argument (2 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+ripgrep-12.1.1/crates/core/args.rs:475:18: this `match` has identical arm bodies
+ripgrep-12.1.1/crates/core/args.rs:512:19: you should put `ArgMatches` between ticks in the documentation
+ripgrep-12.1.1/crates/core/args.rs:549:16: methods called `to_*` usually take self by reference; consider choosing a less ambiguous name
+ripgrep-12.1.1/crates/core/args.rs:76:18: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+ripgrep-12.1.1/crates/core/args.rs:77:13: usage of wildcard import for enum variants
+ripgrep-12.1.1/crates/core/args.rs:923:42: you should put `BinaryDetection::quit` between ticks in the documentation
+ripgrep-12.1.1/crates/core/config.rs:13:1: this import is redundant
+ripgrep-12.1.1/crates/core/config.rs:58:6: very complex type used. Consider factoring parts into `type` definitions
+ripgrep-12.1.1/crates/core/config.rs:79:6: very complex type used. Consider factoring parts into `type` definitions
+ripgrep-12.1.1/crates/core/logger.rs:11:30: you should put `max_level` between ticks in the documentation
+ripgrep-12.1.1/crates/core/logger.rs:15:16: constants have by default a `'static` lifetime
+ripgrep-12.1.1/crates/core/main.rs:55:19: this argument is passed by value, but not consumed in the function body
+ripgrep-12.1.1/crates/core/main.rs:56:9: usage of wildcard import for enum variants
+ripgrep-12.1.1/crates/core/messages.rs:46:1: item name ends with its containing module's name
+ripgrep-12.1.1/crates/core/messages.rs:51:1: item name ends with its containing module's name
+ripgrep-12.1.1/crates/core/messages.rs:62:1: item name ends with its containing module's name
+ripgrep-12.1.1/crates/core/path_printer.rs:27:1: item name starts with its containing module's name
+ripgrep-12.1.1/crates/core/path_printer.rs:89:9: unnecessary boolean `not` operation
+ripgrep-12.1.1/crates/core/search.rs:185:1: item name starts with its containing module's name
+ripgrep-12.1.1/crates/core/search.rs:292:9: using `write!()` with a format string that ends in a single newline
+ripgrep-12.1.1/crates/core/search.rs:311:1: item name starts with its containing module's name
+ripgrep-12.1.1/crates/core/search.rs:377:12: this boolean expression can be simplified
+ripgrep-12.1.1/crates/core/search.rs:423:13: usage of wildcard import for enum variants
+ripgrep-12.1.1/crates/core/search.rs:447:13: usage of wildcard import for enum variants
+ripgrep-12.1.1/crates/core/search.rs:472:24: you are using an explicit closure for cloning elements
+ripgrep-12.1.1/crates/core/search.rs:472:41: redundant closure found
+ripgrep-12.1.1/crates/core/search.rs:480:24: you are using an explicit closure for cloning elements
+ripgrep-12.1.1/crates/core/search.rs:480:41: redundant closure found
+ripgrep-12.1.1/crates/core/search.rs:49:1: item name starts with its containing module's name
+ripgrep-12.1.1/crates/core/search.rs:509:24: you are using an explicit closure for cloning elements
+ripgrep-12.1.1/crates/core/search.rs:509:41: redundant closure found
+ripgrep-12.1.1/crates/core/search.rs:517:24: you are using an explicit closure for cloning elements
+ripgrep-12.1.1/crates/core/search.rs:517:41: redundant closure found
+ripgrep-12.1.1/crates/core/search.rs:533:36: casting `u32` to `f64` may become silently lossy if you later change the type
+ripgrep-12.1.1/crates/core/search.rs:533:5: casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+ripgrep-12.1.1/crates/core/subject.rs:20:1: item name starts with its containing module's name
+ripgrep-12.1.1/crates/core/subject.rs:4:1: this import is redundant
+syn-1.0.54/src/lit.rs:1397:40: redundant else block
+syn-1.0.54/src/lit.rs:1405:28: redundant else block
+syn-1.0.54/src/lit.rs:1485:32: redundant else block
+unicode-xid-0.2.1/src/lib.rs:57:64: you should put `XID_Start` between ticks in the documentation
+unicode-xid-0.2.1/src/lib.rs:60:10: you should put `XID_Start` between ticks in the documentation
+unicode-xid-0.2.1/src/lib.rs:62:27: you should put `ID_Start` between ticks in the documentation
+unicode-xid-0.2.1/src/lib.rs:62:67: you should put `NFKx` between ticks in the documentation
+unicode-xid-0.2.1/src/lib.rs:63:21: methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name
+unicode-xid-0.2.1/src/lib.rs:65:61: you should put `XID_Continue` between ticks in the documentation
+unicode-xid-0.2.1/src/lib.rs:68:10: you should put `XID_Continue` between ticks in the documentation
+unicode-xid-0.2.1/src/lib.rs:70:28: you should put `ID_Continue` between ticks in the documentation
+unicode-xid-0.2.1/src/lib.rs:70:72: you should put `NFKx` between ticks in the documentation
+unicode-xid-0.2.1/src/lib.rs:71:24: methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name
+xsv-0.13.0/src/cmd/cat.rs:101:34: redundant closure found
+xsv-0.13.0/src/cmd/cat.rs:42:1: more than 3 bools in a struct
+xsv-0.13.0/src/cmd/cat.rs:53:9: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/cat.rs:7:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/count.rs:32:9: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/count.rs:38:9: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+xsv-0.13.0/src/cmd/count.rs:42:33: integer type suffix should be separated by an underscore
+xsv-0.13.0/src/cmd/count.rs:50:5: passing a unit value to a function
+xsv-0.13.0/src/cmd/count.rs:7:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/fixlengths.rs:45:9: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/fixlengths.rs:50:18: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+xsv-0.13.0/src/cmd/fixlengths.rs:62:30: integer type suffix should be separated by an underscore
+xsv-0.13.0/src/cmd/fixlengths.rs:9:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/flatten.rs:10:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/flatten.rs:51:9: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/fmt.rs:50:9: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/fmt.rs:55:13: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/fmt.rs:7:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/frequency.rs:148:43: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
+xsv-0.13.0/src/cmd/frequency.rs:149:43: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
+xsv-0.13.0/src/cmd/frequency.rs:15:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/frequency.rs:169:13: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/frequency.rs:176:17: unnecessary boolean `not` operation
+xsv-0.13.0/src/cmd/frequency.rs:178:24: this `else { if .. }` block can be collapsed
+xsv-0.13.0/src/cmd/frequency.rs:77:9: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/frequency.rs:93:31: it is more concise to loop over containers instead of using explicit iteration methods
+xsv-0.13.0/src/cmd/headers.rs:43:9: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/headers.rs:49:17: it is more concise to loop over containers instead of using explicit iteration methods
+xsv-0.13.0/src/cmd/headers.rs:60:22: trait objects without an explicit `dyn` are deprecated
+xsv-0.13.0/src/cmd/headers.rs:9:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/index.rs:11:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/index.rs:45:9: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/input.rs:42:9: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/input.rs:47:9: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/input.rs:7:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/join.rs:17:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/join.rs:194:29: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/join.rs:224:22: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/join.rs:281:44: trait objects without an explicit `dyn` are deprecated
+xsv-0.13.0/src/cmd/join.rs:293:14: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/join.rs:293:20: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/join.rs:297:13: redundant field names in struct initialization
+xsv-0.13.0/src/cmd/join.rs:298:13: redundant field names in struct initialization
+xsv-0.13.0/src/cmd/join.rs:299:13: redundant field names in struct initialization
+xsv-0.13.0/src/cmd/join.rs:300:13: redundant field names in struct initialization
+xsv-0.13.0/src/cmd/join.rs:308:9: unused `self` argument
+xsv-0.13.0/src/cmd/join.rs:342:38: integer type suffix should be separated by an underscore
+xsv-0.13.0/src/cmd/join.rs:342:46: integer type suffix should be separated by an underscore
+xsv-0.13.0/src/cmd/join.rs:347:9: unnecessary boolean `not` operation
+xsv-0.13.0/src/cmd/join.rs:372:44: redundant closure found
+xsv-0.13.0/src/cmd/join.rs:375:33: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/join.rs:392:13: redundant field names in struct initialization
+xsv-0.13.0/src/cmd/join.rs:403:29: it is more concise to loop over containers instead of using explicit iteration methods
+xsv-0.13.0/src/cmd/join.rs:426:13: unnecessary boolean `not` operation
+xsv-0.13.0/src/cmd/join.rs:77:1: more than 3 bools in a struct
+xsv-0.13.0/src/cmd/join.rs:94:9: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/partition.rs:105:22: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/partition.rs:126:36: trait objects without an explicit `dyn` are deprecated
+xsv-0.13.0/src/cmd/partition.rs:139:13: redundant field names in struct initialization
+xsv-0.13.0/src/cmd/partition.rs:15:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/partition.rs:169:9: unnecessary boolean `not` operation
+xsv-0.13.0/src/cmd/partition.rs:56:9: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/partition.rs:77:9: unused `self` argument
+xsv-0.13.0/src/cmd/sample.rs:105:44: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
+xsv-0.13.0/src/cmd/sample.rs:115:21: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
+xsv-0.13.0/src/cmd/sample.rs:11:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/sample.rs:51:9: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/sample.rs:58:19: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+xsv-0.13.0/src/cmd/sample.rs:69:9: wildcard match will miss any future added variants
+xsv-0.13.0/src/cmd/sample.rs:75:16: it is more concise to loop over containers instead of using explicit iteration methods
+xsv-0.13.0/src/cmd/sample.rs:91:42: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
+xsv-0.13.0/src/cmd/sample.rs:92:43: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
+xsv-0.13.0/src/cmd/search.rs:51:9: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/search.rs:9:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/select.rs:60:9: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/select.rs:8:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/slice.rs:57:9: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/slice.rs:9:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/sort.rs:11:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/sort.rs:138:47: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+xsv-0.13.0/src/cmd/sort.rs:139:51: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+xsv-0.13.0/src/cmd/sort.rs:48:9: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/sort.rs:91:14: it is more concise to loop over containers instead of using explicit iteration methods
+xsv-0.13.0/src/cmd/split.rs:131:36: trait objects without an explicit `dyn` are deprecated
+xsv-0.13.0/src/cmd/split.rs:14:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/split.rs:61:9: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/split.rs:94:5: this function's return value is unnecessarily wrapped by `Result`
+xsv-0.13.0/src/cmd/split.rs:96:14: this argument is passed by value, but not consumed in the function body
+xsv-0.13.0/src/cmd/split.rs:99:13: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
+xsv-0.13.0/src/cmd/stats.rs:110:36: redundant closure found
+xsv-0.13.0/src/cmd/stats.rs:127:14: this argument is passed by value, but not consumed in the function body
+xsv-0.13.0/src/cmd/stats.rs:138:43: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
+xsv-0.13.0/src/cmd/stats.rs:139:43: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
+xsv-0.13.0/src/cmd/stats.rs:162:25: it is more concise to loop over containers instead of using explicit iteration methods
+xsv-0.13.0/src/cmd/stats.rs:22:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/stats.rs:231:1: more than 3 bools in a struct
+xsv-0.13.0/src/cmd/stats.rs:262:35: calling `cmd::stats::TypedSum::default()` is more clear than this expression
+xsv-0.13.0/src/cmd/stats.rs:263:40: calling `cmd::stats::TypedMinMax::default()` is more clear than this expression
+xsv-0.13.0/src/cmd/stats.rs:264:39: calling `stats::OnlineStats::default()` is more clear than this expression
+xsv-0.13.0/src/cmd/stats.rs:265:58: calling `stats::Unsorted::default()` is more clear than this expression
+xsv-0.13.0/src/cmd/stats.rs:266:41: calling `stats::Unsorted::default()` is more clear than this expression
+xsv-0.13.0/src/cmd/stats.rs:268:18: calling `cmd::stats::FieldType::default()` is more clear than this expression
+xsv-0.13.0/src/cmd/stats.rs:269:13: redundant field names in struct initialization
+xsv-0.13.0/src/cmd/stats.rs:270:13: redundant field names in struct initialization
+xsv-0.13.0/src/cmd/stats.rs:271:13: redundant field names in struct initialization
+xsv-0.13.0/src/cmd/stats.rs:272:13: redundant field names in struct initialization
+xsv-0.13.0/src/cmd/stats.rs:273:13: redundant field names in struct initialization
+xsv-0.13.0/src/cmd/stats.rs:274:13: redundant field names in struct initialization
+xsv-0.13.0/src/cmd/stats.rs:283:9: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
+xsv-0.13.0/src/cmd/stats.rs:284:9: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
+xsv-0.13.0/src/cmd/stats.rs:285:9: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
+xsv-0.13.0/src/cmd/stats.rs:290:21: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
+xsv-0.13.0/src/cmd/stats.rs:293:25: this `match` has identical arm bodies
+xsv-0.13.0/src/cmd/stats.rs:297:25: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
+xsv-0.13.0/src/cmd/stats.rs:301:21: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
+xsv-0.13.0/src/cmd/stats.rs:302:21: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
+xsv-0.13.0/src/cmd/stats.rs:308:18: methods called `to_*` usually take self by reference; consider choosing a less ambiguous name
+xsv-0.13.0/src/cmd/stats.rs:318:9: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+xsv-0.13.0/src/cmd/stats.rs:322:45: redundant closure found
+xsv-0.13.0/src/cmd/stats.rs:322:9: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+xsv-0.13.0/src/cmd/stats.rs:327:9: unnecessary boolean `not` operation
+xsv-0.13.0/src/cmd/stats.rs:330:13: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+xsv-0.13.0/src/cmd/stats.rs:338:45: redundant closure found
+xsv-0.13.0/src/cmd/stats.rs:402:16: redundant pattern matching, consider using `is_ok()`
+xsv-0.13.0/src/cmd/stats.rs:403:16: redundant pattern matching, consider using `is_ok()`
+xsv-0.13.0/src/cmd/stats.rs:407:18: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+xsv-0.13.0/src/cmd/stats.rs:411:16: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+xsv-0.13.0/src/cmd/stats.rs:427:56: this `match` has identical arm bodies
+xsv-0.13.0/src/cmd/stats.rs:429:56: this `match` has identical arm bodies
+xsv-0.13.0/src/cmd/stats.rs:430:60: this `match` has identical arm bodies
+xsv-0.13.0/src/cmd/stats.rs:430:60: this `match` has identical arm bodies
+xsv-0.13.0/src/cmd/stats.rs:454:5: you should put `TypedSum` between ticks in the documentation
+xsv-0.13.0/src/cmd/stats.rs:473:43: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+xsv-0.13.0/src/cmd/stats.rs:504:56: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+xsv-0.13.0/src/cmd/stats.rs:505:51: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+xsv-0.13.0/src/cmd/stats.rs:511:5: you should put `TypedMinMax` between ticks in the documentation
+xsv-0.13.0/src/cmd/stats.rs:536:35: casting `f64` to `i64` may truncate the value
+xsv-0.13.0/src/cmd/stats.rs:544:33: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
+xsv-0.13.0/src/cmd/stats.rs:592:22: calling `stats::MinMax::default()` is more clear than this expression
+xsv-0.13.0/src/cmd/stats.rs:593:22: calling `stats::MinMax::default()` is more clear than this expression
+xsv-0.13.0/src/cmd/stats.rs:594:23: calling `stats::MinMax::default()` is more clear than this expression
+xsv-0.13.0/src/cmd/stats.rs:595:21: calling `stats::MinMax::default()` is more clear than this expression
+xsv-0.13.0/src/cmd/stats.rs:71:1: more than 3 bools in a struct
+xsv-0.13.0/src/cmd/stats.rs:86:9: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/table.rs:10:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/cmd/table.rs:50:9: binding's name is too similar to existing binding
+xsv-0.13.0/src/cmd/table.rs:54:9: binding's name is too similar to existing binding
+xsv-0.13.0/src/config.rs:113:43: use of `unwrap_or` followed by a function call
+xsv-0.13.0/src/config.rs:197:48: trait objects without an explicit `dyn` are deprecated
+xsv-0.13.0/src/config.rs:202:48: trait objects without an explicit `dyn` are deprecated
+xsv-0.13.0/src/config.rs:263:47: trait objects without an explicit `dyn` are deprecated
+xsv-0.13.0/src/config.rs:293:47: trait objects without an explicit `dyn` are deprecated
+xsv-0.13.0/src/config.rs:58:1: more than 3 bools in a struct
+xsv-0.13.0/src/config.rs:77:28: explicit deref method call
+xsv-0.13.0/src/config.rs:90:13: redundant field names in struct initialization
+xsv-0.13.0/src/index.rs:31:13: redundant field names in struct initialization
+xsv-0.13.0/src/main.rs:164:49: redundant clone
+xsv-0.13.0/src/main.rs:75:16: statics have by default a `'static` lifetime
+xsv-0.13.0/src/select.rs:13:1: item name starts with its containing module's name
+xsv-0.13.0/src/select.rs:154:5: this function's return value is unnecessarily wrapped by `Result`
+xsv-0.13.0/src/select.rs:250:33: binding's name is too similar to existing binding
+xsv-0.13.0/src/select.rs:250:43: binding's name is too similar to existing binding
+xsv-0.13.0/src/select.rs:255:39: an inclusive range would be more readable
+xsv-0.13.0/src/select.rs:280:20: length comparison to zero
+xsv-0.13.0/src/select.rs:29:13: redundant field names in struct initialization
+xsv-0.13.0/src/select.rs:360:62: this argument (8 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
+xsv-0.13.0/src/select.rs:360:9: this function's return value is unnecessarily wrapped by `Option`
+xsv-0.13.0/src/select.rs:375:9: used sort instead of sort_unstable to sort primitive type `usize`
+xsv-0.13.0/src/select.rs:379:18: it is more concise to loop over containers instead of using explicit iteration methods
+xsv-0.13.0/src/select.rs:416:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+xsv-0.13.0/src/select.rs:419:9: this function's return value is unnecessarily wrapped by `Option`
+xsv-0.13.0/src/select.rs:420:27: consider using `Option<T>` instead of `Option<Option<T>>` or a custom enum if you need to distinguish all 3 cases
+xsv-0.13.0/src/select.rs:99:17: binding's name is too similar to existing binding
+xsv-0.13.0/src/util.rs:150:5: you should put bare URLs between `<`/`>` or make a proper Markdown link
+xsv-0.13.0/src/util.rs:190:48: trait objects without an explicit `dyn` are deprecated
+xsv-0.13.0/src/util.rs:37:33: you are using an explicit closure for copying elements
+xsv-0.13.0/src/util.rs:90:1: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)

From f986d78c5e6d401ea3c57c7d00d24d1890675f0c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= <matthias.krueger@famsik.de>
Date: Wed, 23 Dec 2020 01:21:31 +0100
Subject: [PATCH 088/108] cargo dev crater: support multiple versions per crate

---
 clippy_dev/crater_crates.toml | 34 +++++++++++++++++-----------------
 clippy_dev/src/crater.rs      | 32 ++++++++++++++++++++++++++------
 2 files changed, 43 insertions(+), 23 deletions(-)

diff --git a/clippy_dev/crater_crates.toml b/clippy_dev/crater_crates.toml
index e69056c9925d5..1fbf7930d3ecf 100644
--- a/clippy_dev/crater_crates.toml
+++ b/clippy_dev/crater_crates.toml
@@ -1,20 +1,20 @@
 [crates]
 # some of these are from cargotest
-cargo = '0.49.0'
-iron = '0.6.1'
-ripgrep = '12.1.1'
-xsv = '0.13.0'
-#tokei = '12.0.4'
-rayon = '1.5.0'
-serde = '1.0.118'
+cargo = ['0.49.0']
+iron = ['0.6.1']
+ripgrep = ['12.1.1']
+xsv = ['0.13.0']
+#tokei = ['12.0.4']
+rayon = ['1.5.0']
+serde = ['1.0.118']
 # top 10 crates.io dls
-bitflags = '1.2.1'
-libc = '0.2.81'
-log = '0.4.11'
-proc-macro2 = '1.0.24'
-quote = '1.0.7'
-rand = '0.7.3'
-rand_core = '0.6.0'
-regex = '1.3.2'
-syn = '1.0.54'
-unicode-xid = '0.2.1'
+bitflags = ['1.2.1']
+libc = ['0.2.81']
+log = ['0.4.11']
+proc-macro2 = ['1.0.24']
+quote = ['1.0.7']
+rand = ['0.7.3']
+rand_core = ['0.6.0']
+regex = ['1.3.2']
+syn = ['1.0.54']
+unicode-xid = ['0.2.1']
diff --git a/clippy_dev/src/crater.rs b/clippy_dev/src/crater.rs
index f64ab897906c3..a681bf10496d8 100644
--- a/clippy_dev/src/crater.rs
+++ b/clippy_dev/src/crater.rs
@@ -6,17 +6,24 @@ use std::collections::HashMap;
 use std::process::Command;
 use std::{fs::write, path::PathBuf};
 
+// crate data we stored in the toml, can have multiple versions.
+// if so, one TomlKrate maps to several KrateSources
+struct TomlKrate {
+    name: String,
+    versions: Vec<String>,
+}
+
 // represents an archive we download from crates.io
 #[derive(Debug, Serialize, Deserialize, Eq, Hash, PartialEq)]
 struct KrateSource {
-    version: String,
     name: String,
+    version: String,
 }
 
 // use this to store the crates when interacting with the crates.toml file
 #[derive(Debug, Serialize, Deserialize)]
 struct CrateList {
-    crates: HashMap<String, String>,
+    crates: HashMap<String, Vec<String>>,
 }
 
 // represents the extracted sourcecode of a crate
@@ -145,11 +152,24 @@ fn read_crates() -> Vec<KrateSource> {
     let crate_list: CrateList =
         toml::from_str(&toml_content).unwrap_or_else(|e| panic!("Failed to parse {}: \n{}", toml_path.display(), e));
     // parse the hashmap of the toml file into a list of crates
-    crate_list
+    let tomlkrates: Vec<TomlKrate> = crate_list
         .crates
-        .iter()
-        .map(|(name, version)| KrateSource::new(&name, &version))
-        .collect()
+        .into_iter()
+        .map(|(name, versions)| TomlKrate { name, versions })
+        .collect();
+
+    // flatten TomlKrates into KrateSources (one TomlKrates may represent several versions of a crate =>
+    // multiple kratesources)
+    let mut krate_sources = Vec::new();
+    tomlkrates.into_iter().for_each(|tk| {
+        tk.versions.iter().for_each(|ver| {
+            krate_sources.push(KrateSource {
+                name: tk.name.clone(),
+                version: ver.to_string(),
+            });
+        })
+    });
+    krate_sources
 }
 
 // the main fn

From 22824d21da0397d61c15a56dbb88405f4866293d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= <matthias.krueger@famsik.de>
Date: Wed, 23 Dec 2020 13:02:02 +0100
Subject: [PATCH 089/108] rename symbols: krate -> crate

---
 clippy_dev/src/crater.rs | 51 ++++++++++++++++++++--------------------
 1 file changed, 26 insertions(+), 25 deletions(-)

diff --git a/clippy_dev/src/crater.rs b/clippy_dev/src/crater.rs
index a681bf10496d8..6202acfad06c9 100644
--- a/clippy_dev/src/crater.rs
+++ b/clippy_dev/src/crater.rs
@@ -1,21 +1,29 @@
+// Run clippy on a fixed set of crates and collect the warnings.
+// This helps observing the impact clippy changs have on a set of real-world code.
+//
+// When a new lint is introduced, we can search the results for new warnings and check for false
+// positives.
+
 #![allow(clippy::filter_map)]
 
 use crate::clippy_project_root;
-use serde::{Deserialize, Serialize};
+
 use std::collections::HashMap;
 use std::process::Command;
 use std::{fs::write, path::PathBuf};
 
+use serde::{Deserialize, Serialize};
+
 // crate data we stored in the toml, can have multiple versions.
 // if so, one TomlKrate maps to several KrateSources
-struct TomlKrate {
+struct TomlCrate {
     name: String,
     versions: Vec<String>,
 }
 
 // represents an archive we download from crates.io
 #[derive(Debug, Serialize, Deserialize, Eq, Hash, PartialEq)]
-struct KrateSource {
+struct CrateSource {
     name: String,
     version: String,
 }
@@ -28,22 +36,15 @@ struct CrateList {
 
 // represents the extracted sourcecode of a crate
 #[derive(Debug)]
-struct Krate {
+struct Crate {
     version: String,
     name: String,
     // path to the extracted sources that clippy can check
     path: PathBuf,
 }
 
-impl KrateSource {
-    fn new(name: &str, version: &str) -> Self {
-        KrateSource {
-            version: version.into(),
-            name: name.into(),
-        }
-    }
-
-    fn download_and_extract(&self) -> Krate {
+impl CrateSource {
+    fn download_and_extract(&self) -> Crate {
         let extract_dir = PathBuf::from("target/crater/crates");
         let krate_download_dir = PathBuf::from("target/crater/downloads");
 
@@ -80,7 +81,7 @@ impl KrateSource {
         }
         // crate is extracted, return a new Krate object which contains the path to the extracted
         // sources that clippy can check
-        Krate {
+        Crate {
             version: self.version.clone(),
             name: self.name.clone(),
             path: extract_dir.join(format!("{}-{}/", self.name, self.version)),
@@ -88,7 +89,7 @@ impl KrateSource {
     }
 }
 
-impl Krate {
+impl Crate {
     fn run_clippy_lints(&self, cargo_clippy_path: &PathBuf) -> Vec<String> {
         println!("Linting {} {}...", &self.name, &self.version);
         let cargo_clippy_path = std::fs::canonicalize(cargo_clippy_path).unwrap();
@@ -144,32 +145,32 @@ fn build_clippy() {
         .expect("Failed to build clippy!");
 }
 
-// get a list of KrateSources we want to check from a "crater_crates.toml" file.
-fn read_crates() -> Vec<KrateSource> {
+// get a list of CrateSources we want to check from a "crater_crates.toml" file.
+fn read_crates() -> Vec<CrateSource> {
     let toml_path = PathBuf::from("clippy_dev/crater_crates.toml");
     let toml_content: String =
         std::fs::read_to_string(&toml_path).unwrap_or_else(|_| panic!("Failed to read {}", toml_path.display()));
     let crate_list: CrateList =
         toml::from_str(&toml_content).unwrap_or_else(|e| panic!("Failed to parse {}: \n{}", toml_path.display(), e));
     // parse the hashmap of the toml file into a list of crates
-    let tomlkrates: Vec<TomlKrate> = crate_list
+    let tomlcrates: Vec<TomlCrate> = crate_list
         .crates
         .into_iter()
-        .map(|(name, versions)| TomlKrate { name, versions })
+        .map(|(name, versions)| TomlCrate { name, versions })
         .collect();
 
-    // flatten TomlKrates into KrateSources (one TomlKrates may represent several versions of a crate =>
-    // multiple kratesources)
-    let mut krate_sources = Vec::new();
-    tomlkrates.into_iter().for_each(|tk| {
+    // flatten TomlCrates into CrateSources (one TomlCrates may represent several versions of a crate =>
+    // multiple Cratesources)
+    let mut crate_sources = Vec::new();
+    tomlcrates.into_iter().for_each(|tk| {
         tk.versions.iter().for_each(|ver| {
-            krate_sources.push(KrateSource {
+            crate_sources.push(CrateSource {
                 name: tk.name.clone(),
                 version: ver.to_string(),
             });
         })
     });
-    krate_sources
+    crate_sources
 }
 
 // the main fn

From 62337f284281637a73a8d4770315850fbf4067aa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= <matthias.krueger@famsik.de>
Date: Wed, 23 Dec 2020 13:03:19 +0100
Subject: [PATCH 090/108] remove duplicate code and other cleanup

---
 clippy_dev/Cargo.toml    |  4 ++--
 clippy_dev/src/crater.rs | 28 +++++++++++-----------------
 mini-crater/logs.txt     |  1 +
 3 files changed, 14 insertions(+), 19 deletions(-)

diff --git a/clippy_dev/Cargo.toml b/clippy_dev/Cargo.toml
index 6c6941837f121..e41ed77fcb95d 100644
--- a/clippy_dev/Cargo.toml
+++ b/clippy_dev/Cargo.toml
@@ -1,8 +1,8 @@
 [package]
-authors = ["Philipp Hansch <dev@phansch.net>"]
-edition = "2018"
 name = "clippy_dev"
 version = "0.0.1"
+authors = ["Philipp Hansch <dev@phansch.net>"]
+edition = "2018"
 
 [dependencies]
 bytecount = "0.6"
diff --git a/clippy_dev/src/crater.rs b/clippy_dev/src/crater.rs
index 6202acfad06c9..8a6ce0a89216f 100644
--- a/clippy_dev/src/crater.rs
+++ b/clippy_dev/src/crater.rs
@@ -14,8 +14,14 @@ use std::{fs::write, path::PathBuf};
 
 use serde::{Deserialize, Serialize};
 
-// crate data we stored in the toml, can have multiple versions.
-// if so, one TomlKrate maps to several KrateSources
+// use this to store the crates when interacting with the crates.toml file
+#[derive(Debug, Serialize, Deserialize)]
+struct CrateList {
+    crates: HashMap<String, Vec<String>>,
+}
+
+// crate data we stored in the toml, can have multiple versions per crate
+// A single TomlCrate is laster mapped to several CrateSources in that case
 struct TomlCrate {
     name: String,
     versions: Vec<String>,
@@ -28,12 +34,6 @@ struct CrateSource {
     version: String,
 }
 
-// use this to store the crates when interacting with the crates.toml file
-#[derive(Debug, Serialize, Deserialize)]
-struct CrateList {
-    crates: HashMap<String, Vec<String>>,
-}
-
 // represents the extracted sourcecode of a crate
 #[derive(Debug)]
 struct Crate {
@@ -70,14 +70,8 @@ impl CrateSource {
             // unzip the tarball
             let ungz_tar = flate2::read::GzDecoder::new(std::fs::File::open(&krate_file_path).unwrap());
             // extract the tar archive
-            let mut archiv = tar::Archive::new(ungz_tar);
-            archiv.unpack(&extract_dir).expect("Failed to extract!");
-
-            // unzip the tarball
-            let ungz_tar = flate2::read::GzDecoder::new(std::fs::File::open(&krate_file_path).unwrap());
-            // extract the tar archive
-            let mut archiv = tar::Archive::new(ungz_tar);
-            archiv.unpack(&extract_dir).expect("Failed to extract!");
+            let mut archive = tar::Archive::new(ungz_tar);
+            archive.unpack(&extract_dir).expect("Failed to extract!");
         }
         // crate is extracted, return a new Krate object which contains the path to the extracted
         // sources that clippy can check
@@ -132,7 +126,7 @@ impl Crate {
             })
             .collect();
 
-        // sort messages alphabtically to avoid noise in the logs
+        // sort messages alphabetically to avoid noise in the logs
         output.sort();
         output
     }
diff --git a/mini-crater/logs.txt b/mini-crater/logs.txt
index dfa6450def7f9..42d978f4db404 100644
--- a/mini-crater/logs.txt
+++ b/mini-crater/logs.txt
@@ -1423,6 +1423,7 @@ iron-0.6.1/src/request/mod.rs:85:24: binding's name is too similar to existing b
 iron-0.6.1/src/request/url.rs:109:5: this method could have a `#[must_use]` attribute
 iron-0.6.1/src/request/url.rs:117:5: this method could have a `#[must_use]` attribute
 iron-0.6.1/src/request/url.rs:124:9: use of deprecated macro `try`: use the `?` operator instead
+iron-0.6.1/src/request/url.rs:129:1: an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true
 iron-0.6.1/src/request/url.rs:21:14: you should put bare URLs between `<`/`>` or make a proper Markdown link
 iron-0.6.1/src/request/url.rs:22:5: docs for function returning `Result` missing `# Errors` section
 iron-0.6.1/src/request/url.rs:31:5: docs for function returning `Result` missing `# Errors` section

From 6c5bf2778fa09fd3a79dd2fa76779c07ee182391 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= <matthias.krueger@famsik.de>
Date: Wed, 23 Dec 2020 15:00:51 +0100
Subject: [PATCH 091/108] clippy dev crater: use and parse clippy messages as
 json message, to get the lint name of a warning

---
 clippy_dev/Cargo.toml    |    1 +
 clippy_dev/src/crater.rs |   76 +-
 mini-crater/logs.txt     | 6494 +++++++++++++++++++-------------------
 3 files changed, 3306 insertions(+), 3265 deletions(-)

diff --git a/clippy_dev/Cargo.toml b/clippy_dev/Cargo.toml
index e41ed77fcb95d..d666314514206 100644
--- a/clippy_dev/Cargo.toml
+++ b/clippy_dev/Cargo.toml
@@ -12,6 +12,7 @@ itertools = "0.9"
 opener = "0.4"
 regex = "1"
 serde = {version = "1.0", features = ["derive"]}
+serde_json = "1.0"
 shell-escape = "0.1"
 tar = "0.4.30"
 toml = "0.5"
diff --git a/clippy_dev/src/crater.rs b/clippy_dev/src/crater.rs
index 8a6ce0a89216f..db0dd3641f10e 100644
--- a/clippy_dev/src/crater.rs
+++ b/clippy_dev/src/crater.rs
@@ -10,9 +10,10 @@ use crate::clippy_project_root;
 
 use std::collections::HashMap;
 use std::process::Command;
-use std::{fs::write, path::PathBuf};
+use std::{fmt, fs::write, path::PathBuf};
 
 use serde::{Deserialize, Serialize};
+use serde_json::Value;
 
 // use this to store the crates when interacting with the crates.toml file
 #[derive(Debug, Serialize, Deserialize)]
@@ -43,6 +44,27 @@ struct Crate {
     path: PathBuf,
 }
 
+#[derive(Debug)]
+struct ClippyWarning {
+    crate_name: String,
+    crate_version: String,
+    file: String,
+    line: String,
+    column: String,
+    linttype: String,
+    message: String,
+}
+
+impl std::fmt::Display for ClippyWarning {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        writeln!(
+            f,
+            r#"{}/{}/{}:{}:{} {} "{}""#,
+            &self.crate_name, &self.crate_version, &self.file, &self.line, &self.column, &self.linttype, &self.message
+        )
+    }
+}
+
 impl CrateSource {
     fn download_and_extract(&self) -> Crate {
         let extract_dir = PathBuf::from("target/crater/crates");
@@ -96,7 +118,7 @@ impl Crate {
             // src/cargo/ops/cargo_compile.rs:127:35: warning: usage of `FromIterator::from_iter`
             .args(&[
                 "--",
-                "--message-format=short",
+                "--message-format=json",
                 "--",
                 "--cap-lints=warn",
                 "-Wclippy::pedantic",
@@ -105,27 +127,17 @@ impl Crate {
             .current_dir(&self.path)
             .output()
             .unwrap();
-        let stderr = String::from_utf8_lossy(&all_output.stderr);
-        let output_lines = stderr.lines();
-        let mut output: Vec<String> = output_lines
+        let stdout = String::from_utf8_lossy(&all_output.stdout);
+        let output_lines = stdout.lines();
+        //dbg!(&output_lines);
+        let warnings: Vec<ClippyWarning> = output_lines
             .into_iter()
-            .filter(|line| line.contains(": warning: "))
-            // prefix with the crate name and version
-            // cargo-0.49.0/src/cargo/ops/cargo_compile.rs:127:35: warning: usage of `FromIterator::from_iter`
-            .map(|line| format!("{}-{}/{}", self.name, self.version, line))
-            // remove the "warning: "
-            .map(|line| {
-                let remove_pat = "warning: ";
-                let pos = line
-                    .find(&remove_pat)
-                    .expect("clippy output did not contain \"warning: \"");
-                let mut new = line[0..pos].to_string();
-                new.push_str(&line[pos + remove_pat.len()..]);
-                new.push('\n');
-                new
-            })
+            // get all clippy warnings
+            .filter(|line| line.contains("clippy::"))
+            .map(|json_msg| parse_json_message(json_msg, &self))
             .collect();
 
+        let mut output: Vec<String> = warnings.iter().map(|warning| warning.to_string()).collect();
         // sort messages alphabetically to avoid noise in the logs
         output.sort();
         output
@@ -167,6 +179,30 @@ fn read_crates() -> Vec<CrateSource> {
     crate_sources
 }
 
+// extract interesting data from a json lint message
+fn parse_json_message(json_message: &str, krate: &Crate) -> ClippyWarning {
+    let jmsg: Value = serde_json::from_str(&json_message).unwrap_or_else(|e| panic!("Failed to parse json:\n{:?}", e));
+
+    ClippyWarning {
+        crate_name: krate.name.to_string(),
+        crate_version: krate.version.to_string(),
+        file: jmsg["message"]["spans"][0]["file_name"]
+            .to_string()
+            .trim_matches('"')
+            .into(),
+        line: jmsg["message"]["spans"][0]["line_start"]
+            .to_string()
+            .trim_matches('"')
+            .into(),
+        column: jmsg["message"]["spans"][0]["text"][0]["highlight_start"]
+            .to_string()
+            .trim_matches('"')
+            .into(),
+        linttype: jmsg["message"]["code"]["code"].to_string().trim_matches('"').into(),
+        message: jmsg["message"]["message"].to_string().trim_matches('"').into(),
+    }
+}
+
 // the main fn
 pub fn run() {
     let cargo_clippy_path: PathBuf = PathBuf::from("target/debug/cargo-clippy");
diff --git a/mini-crater/logs.txt b/mini-crater/logs.txt
index 42d978f4db404..52045f05faaff 100644
--- a/mini-crater/logs.txt
+++ b/mini-crater/logs.txt
@@ -1,3245 +1,3249 @@
-cargo-0.49.0/src/bin/cargo/cli.rs:104:34: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-cargo-0.49.0/src/bin/cargo/cli.rs:121:5: calling `push_str()` using a single-character string literal
-cargo-0.49.0/src/bin/cargo/cli.rs:157:30: redundant closure found
-cargo-0.49.0/src/bin/cargo/cli.rs:184:41: casting `u64` to `u32` may truncate the value
-cargo-0.49.0/src/bin/cargo/cli.rs:196:42: redundant closure found
-cargo-0.49.0/src/bin/cargo/cli.rs:200:39: redundant closure found
-cargo-0.49.0/src/bin/cargo/cli.rs:231:1: more than 3 bools in a struct
-cargo-0.49.0/src/bin/cargo/cli.rs:245:22: casting `u64` to `u32` may truncate the value
-cargo-0.49.0/src/bin/cargo/cli.rs:247:47: redundant closure found
-cargo-0.49.0/src/bin/cargo/cli.rs:257:22: redundant closure found
-cargo-0.49.0/src/bin/cargo/cli.rs:26:20: redundant else block
-cargo-0.49.0/src/bin/cargo/cli.rs:7:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/commands/bench.rs:1:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/commands/bench.rs:76:59: redundant closure found
-cargo-0.49.0/src/bin/cargo/commands/build.rs:1:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/commands/check.rs:1:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/commands/clean.rs:1:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/commands/doc.rs:1:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/commands/fetch.rs:1:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/commands/fix.rs:1:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/commands/generate_lockfile.rs:1:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/commands/git_checkout.rs:1:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/commands/help.rs:20:1: item name ends with its containing module's name
-cargo-0.49.0/src/bin/cargo/commands/init.rs:1:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/commands/install.rs:1:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/commands/install.rs:97:16: use Option::map_or instead of an if let/else
-cargo-0.49.0/src/bin/cargo/commands/locate_project.rs:1:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/commands/login.rs:1:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/commands/metadata.rs:1:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/commands/mod.rs:1:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/commands/new.rs:1:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/commands/new.rs:20:24: use Option::map_or instead of an if let/else
-cargo-0.49.0/src/bin/cargo/commands/owner.rs:1:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/commands/owner.rs:38:43: redundant closure found
-cargo-0.49.0/src/bin/cargo/commands/owner.rs:39:43: redundant closure found
-cargo-0.49.0/src/bin/cargo/commands/owner.rs:40:43: redundant closure found
-cargo-0.49.0/src/bin/cargo/commands/owner.rs:43:30: redundant closure found
-cargo-0.49.0/src/bin/cargo/commands/owner.rs:46:30: redundant closure found
-cargo-0.49.0/src/bin/cargo/commands/package.rs:1:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/commands/pkgid.rs:1:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/commands/publish.rs:1:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/commands/publish.rs:40:47: redundant closure found
-cargo-0.49.0/src/bin/cargo/commands/read_manifest.rs:1:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/commands/run.rs:1:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/commands/rustc.rs:1:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/commands/rustdoc.rs:3:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/commands/search.rs:1:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/commands/test.rs:127:54: redundant closure found
-cargo-0.49.0/src/bin/cargo/commands/test.rs:1:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/commands/tree.rs:149:49: redundant closure found
-cargo-0.49.0/src/bin/cargo/commands/tree.rs:2:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/commands/uninstall.rs:1:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/commands/update.rs:1:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/commands/vendor.rs:1:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/commands/vendor.rs:96:16: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
-cargo-0.49.0/src/bin/cargo/commands/verify_project.rs:1:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/commands/version.rs:2:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/commands/yank.rs:1:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/commands/yank.rs:32:36: redundant closure found
-cargo-0.49.0/src/bin/cargo/commands/yank.rs:33:35: redundant closure found
-cargo-0.49.0/src/bin/cargo/commands/yank.rs:34:36: redundant closure found
-cargo-0.49.0/src/bin/cargo/commands/yank.rs:35:36: redundant closure found
-cargo-0.49.0/src/bin/cargo/main.rs:100:17: wildcard match will miss any future added variants
-cargo-0.49.0/src/bin/cargo/main.rs:118:41: redundant closure found
-cargo-0.49.0/src/bin/cargo/main.rs:137:43: redundant closure found
-cargo-0.49.0/src/bin/cargo/main.rs:148:19: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-cargo-0.49.0/src/bin/cargo/main.rs:174:57: redundant closure found
-cargo-0.49.0/src/bin/cargo/main.rs:18:5: usage of wildcard import
-cargo-0.49.0/src/bin/cargo/main.rs:72:22: redundant closure found
-cargo-0.49.0/src/bin/cargo/main.rs:94:13: wildcard match will miss any future added variants
-cargo-0.49.0/src/bin/cargo/main.rs:96:41: redundant closure found
-cargo-0.49.0/src/bin/cargo/main.rs:98:60: redundant closure found
-cargo-0.49.0/src/cargo/core/compiler/build_config.rs:155:13: usage of wildcard import for enum variants
-cargo-0.49.0/src/cargo/core/compiler/build_config.rs:170:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/compiler/build_config.rs:175:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/compiler/build_config.rs:180:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/compiler/build_config.rs:186:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/compiler/build_config.rs:197:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/compiler/build_config.rs:205:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/compiler/build_config.rs:51:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/compiler/build_config.rs:69:48: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-cargo-0.49.0/src/cargo/core/compiler/build_config.rs:96:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/compiler/build_context/mod.rs:44:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/compiler/build_context/mod.rs:83:20: you should put `x86_64` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:108:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:121:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:149:9: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:420:69: you should put `mode/target_kind` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:423:19: you should put `CrateTypes` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:424:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:469:58: redundant closure found
-cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:591:20: called `filter(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:603:19: redundant closure found
-cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:665:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:82:31: you should put `FileType` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:83:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:84:9: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:96:31: you should put `FileType` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:98:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/compiler/build_plan.rs:4:9: you should put `BuildPlan` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/compiler/build_plan.rs:5:66: you should put `BuildPlan` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/compiler/compilation.rs:150:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/compiler/compilation.rs:169:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/compiler/compilation.rs:185:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/compiler/compilation.rs:193:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/compiler/compilation.rs:194:49: redundant closure found
-cargo-0.49.0/src/cargo/core/compiler/compilation.rs:198:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/compiler/compilation.rs:314:16: you should put `rustc_tool` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/compiler/compilation.rs:91:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/compiler/compile_kind.rs:118:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/compiler/compile_kind.rs:147:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/compiler/compile_kind.rs:157:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/compiler/compile_kind.rs:29:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/compiler/compile_kind.rs:33:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/compiler/compile_kind.rs:49:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/compiler/context/compilation_files.rs:204:9: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-cargo-0.49.0/src/cargo/core/compiler/context/compilation_files.rs:277:22: you should put `OUT_DIR` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/compiler/context/compilation_files.rs:324:66: you should put `FileType` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/compiler/context/compilation_files.rs:393:37: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/core/compiler/context/compilation_files.rs:426:71: redundant closure found
-cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:125:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:125:5: this function has too many lines (107/100)
-cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:270:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:286:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:308:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:340:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:349:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:354:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:358:21: you should put `RunCustomBuild` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:361:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:365:9: called `find(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:374:43: you should put `RunCustomBuild` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:378:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:383:41: you should put `RunCustomBuild` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:384:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:391:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:397:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:523:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:538:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:542:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:83:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:92:25: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-cargo-0.49.0/src/cargo/core/compiler/crate_type.rs:16:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/compiler/crate_type.rs:29:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/compiler/crate_type.rs:40:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/compiler/crate_type.rs:49:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/compiler/crate_type.rs:60:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:150:1: this function has too many lines (230/100)
-cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:154:29: called `find(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:353:56: stripping a prefix manually
-cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:448:27: this argument is passed by value, but not consumed in the function body
-cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:464:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:481:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:48:56: you should put `RunCustomBuild` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:561:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:567:20: redundant closure found
-cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:576:28: `mut value` is being shadowed
-cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:606:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:624:13: called `find(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:688:5: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:756:5: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:762:5: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:762:5: this function's return value is unnecessarily wrapped by `Result`
-cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:823:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1021:51: redundant closure found
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1252:20: called `filter(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1278:19: called `filter(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1656:16: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1664:5: field assignment outside of initializer for an instance created with Default::default()
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1787:5: binding's name is too similar to existing binding
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1795:5: field assignment outside of initializer for an instance created with Default::default()
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1882:17: binding's name is too similar to existing binding
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1894:17: binding's name is too similar to existing binding
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1906:9: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1917:9: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1923:9: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1956:9: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1962:9: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1963:22: casting `usize` to `u8` may truncate the value
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1964:22: casting `usize` to `u8` may truncate the value
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1965:22: casting `usize` to `u8` may truncate the value
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1966:22: casting `usize` to `u8` may truncate the value
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1980:17: binding's name is too similar to existing binding
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1980:24: stripping a prefix manually
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1986:17: binding's name is too similar to existing binding
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:2016:5: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:61:5: you should put `CompileMode` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:63:12: you should put `CompileKind` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:67:7: you should put `CARGO_DEFAULT_LIB_METADATA[^4` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:68:5: you should put `package_id` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:71:19: you should put `test/bench/for_host/edition` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:755:52: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:77:5: you should put `is_std` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:816:5: this function has too many lines (127/100)
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:863:64: binding's name is too similar to existing binding
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:875:33: binding's name is too similar to existing binding
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:876:32: binding's name is too similar to existing binding
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:896:30: binding's name is too similar to existing binding
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:897:30: binding's name is too similar to existing binding
-cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:991:37: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:12:5: you should put `src/librustc_jobserver/lib.rs` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:282:30: called `filter(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:329:13: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:332:23: this argument is passed by value, but not consumed in the function body
-cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:34:53: you should put `NeedsToken` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:35:6: you should put `ReleaseToken` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:37:6: you should put `NeedsToken` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:40:56: you should put `NeedsToken` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:40:5: you should put `NeedsToken` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:43:6: you should put `ReleaseToken` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:749:13: unnecessary boolean `not` operation
-cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:786:26: unused `self` argument
-cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:81:61: you should put `DrainState` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:865:13: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:871:13: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:890:9: unused `self` argument
-cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:93:24: you should put `JobQueue` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/compiler/links.rs:8:1: item name ends with its containing module's name
-cargo-0.49.0/src/cargo/core/compiler/mod.rs:1016:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/compiler/mod.rs:1094:19: redundant closure found
-cargo-0.49.0/src/cargo/core/compiler/mod.rs:1131:1: this function's return value is unnecessarily wrapped by `Result`
-cargo-0.49.0/src/cargo/core/compiler/mod.rs:1277:5: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/core/compiler/mod.rs:179:1: this function has too many lines (162/100)
-cargo-0.49.0/src/cargo/core/compiler/mod.rs:198:78: redundant closure found
-cargo-0.49.0/src/cargo/core/compiler/mod.rs:201:25: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-cargo-0.49.0/src/cargo/core/compiler/mod.rs:267:9: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/core/compiler/mod.rs:324:5: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/core/compiler/mod.rs:364:5: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/core/compiler/mod.rs:364:5: this function's return value is unnecessarily wrapped by `Result`
-cargo-0.49.0/src/cargo/core/compiler/mod.rs:392:45: redundant closure found
-cargo-0.49.0/src/cargo/core/compiler/mod.rs:415:23: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-cargo-0.49.0/src/cargo/core/compiler/mod.rs:667:15: binding's name is too similar to existing binding
-cargo-0.49.0/src/cargo/core/compiler/mod.rs:693:1: this function's return value is unnecessarily wrapped by `Result`
-cargo-0.49.0/src/cargo/core/compiler/mod.rs:725:42: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/core/compiler/mod.rs:736:1: this function has too many lines (141/100)
-cargo-0.49.0/src/cargo/core/compiler/mod.rs:73:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/compiler/mod.rs:777:12: unnecessary boolean `not` operation
-cargo-0.49.0/src/cargo/core/compiler/mod.rs:873:5: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/core/compiler/output_depinfo.rs:41:13: wildcard match will miss any future added variants
-cargo-0.49.0/src/cargo/core/compiler/rustdoc.rs:16:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/core/compiler/rustdoc.rs:57:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/core/compiler/rustdoc.rs:72:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/compiler/standard_lib.rs:134:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/compiler/standard_lib.rs:16:1: this function could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/compiler/standard_lib.rs:30:28: redundant closure found
-cargo-0.49.0/src/cargo/core/compiler/standard_lib.rs:34:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/compiler/timings.rs:16:1: more than 3 bools in a struct
-cargo-0.49.0/src/cargo/core/compiler/timings.rs:192:64: this argument is passed by value, but not consumed in the function body
-cargo-0.49.0/src/cargo/core/compiler/timings.rs:212:58: this argument is passed by value, but not consumed in the function body
-cargo-0.49.0/src/cargo/core/compiler/timings.rs:234:13: non-binding `let` on a type that implements `Drop`
-cargo-0.49.0/src/cargo/core/compiler/timings.rs:355:13: casting `f64` to `u32` may lose the sign of the value
-cargo-0.49.0/src/cargo/core/compiler/timings.rs:355:13: casting `f64` to `u32` may truncate the value
-cargo-0.49.0/src/cargo/core/compiler/timings.rs:397:38: casting `f64` to `u32` may lose the sign of the value
-cargo-0.49.0/src/cargo/core/compiler/timings.rs:397:38: casting `f64` to `u32` may truncate the value
-cargo-0.49.0/src/cargo/core/compiler/timings.rs:484:9: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/core/compiler/timings.rs:605:38: you should put `rmeta_time` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/compiler/timings.rs:605:50: you should put `codegen_time` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/compiler/timings.rs:641:26: literal non-ASCII character detected
-cargo-0.49.0/src/cargo/core/compiler/unit.rs:100:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/compiler/unit.rs:151:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/core/compiler/unit.rs:161:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/compiler/unit.rs:35:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/core/compiler/unit_dependencies.rs:154:29: you should put `state.unit_dependencies` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/compiler/unit_dependencies.rs:213:1: this function has too many lines (110/100)
-cargo-0.49.0/src/cargo/core/compiler/unit_dependencies.rs:329:13: called `filter(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/core/compiler/unit_dependencies.rs:480:5: called `find(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/core/compiler/unit_dependencies.rs:511:5: called `find(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/core/compiler/unit_dependencies.rs:52:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/compiler/unit_dependencies.rs:52:1: item name ends with its containing module's name
-cargo-0.49.0/src/cargo/core/compiler/unit_graph.rs:65:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/compiler/unit_graph.rs:65:1: item name ends with its containing module's name
-cargo-0.49.0/src/cargo/core/dependency.rs:157:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/dependency.rs:182:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/dependency.rs:203:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/dependency.rs:224:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/dependency.rs:23:1: more than 3 bools in a struct
-cargo-0.49.0/src/cargo/core/dependency.rs:248:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/dependency.rs:270:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/dependency.rs:274:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/dependency.rs:278:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/dependency.rs:287:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/dependency.rs:291:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/dependency.rs:305:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/dependency.rs:311:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/dependency.rs:319:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/dependency.rs:337:75: redundant closure found
-cargo-0.49.0/src/cargo/core/dependency.rs:397:56: redundant closure found
-cargo-0.49.0/src/cargo/core/dependency.rs:403:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/dependency.rs:408:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/dependency.rs:415:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/dependency.rs:419:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/dependency.rs:424:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/dependency.rs:428:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/dependency.rs:433:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/dependency.rs:438:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/dependency.rs:443:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/dependency.rs:449:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/dependency.rs:450:9: unnecessary `!=` operation
-cargo-0.49.0/src/cargo/core/features.rs:119:17: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/features.rs:229:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/features.rs:274:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/features.rs:278:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/features.rs:306:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/features.rs:338:1: more than 3 bools in a struct
-cargo-0.49.0/src/cargo/core/features.rs:362:25: consider using `Option<T>` instead of `Option<Option<T>>` or a custom enum if you need to distinguish all 3 cases
-cargo-0.49.0/src/cargo/core/features.rs:380:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/features.rs:401:9: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/core/features.rs:409:9: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/core/features.rs:412:45: redundant closure found
-cargo-0.49.0/src/cargo/core/features.rs:416:9: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/core/features.rs:419:45: redundant closure found
-cargo-0.49.0/src/cargo/core/features.rs:424:9: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/core/features.rs:431:9: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/core/features.rs:477:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/features.rs:509:1: this function could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/features.rs:518:5: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
-cargo-0.49.0/src/cargo/core/features.rs:542:1: this function could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/features.rs:543:37: redundant closure found
-cargo-0.49.0/src/cargo/core/features.rs:547:60: redundant closure found
-cargo-0.49.0/src/cargo/core/features.rs:556:1: item name ends with its containing module's name
-cargo-0.49.0/src/cargo/core/features.rs:563:1: item name ends with its containing module's name
-cargo-0.49.0/src/cargo/core/manifest.rs:116:13: usage of wildcard import for enum variants
-cargo-0.49.0/src/cargo/core/manifest.rs:118:58: redundant closure found
-cargo-0.49.0/src/cargo/core/manifest.rs:130:13: usage of wildcard import for enum variants
-cargo-0.49.0/src/cargo/core/manifest.rs:143:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:159:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:162:34: redundant closure found
-cargo-0.49.0/src/cargo/core/manifest.rs:169:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:17:5: usage of wildcard import
-cargo-0.49.0/src/cargo/core/manifest.rs:189:1: more than 3 bools in a struct
-cargo-0.49.0/src/cargo/core/manifest.rs:215:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:222:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:22:1: item name ends with its containing module's name
-cargo-0.49.0/src/cargo/core/manifest.rs:360:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:407:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:410:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:413:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:416:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:419:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:422:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:425:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:431:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:438:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:444:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:447:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:450:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:453:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:456:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:459:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:462:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:466:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:470:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:477:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:481:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:488:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/manifest.rs:512:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:516:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:520:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:524:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:528:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:538:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:557:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:561:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:565:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:569:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:577:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:581:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:588:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:617:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:632:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:648:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:659:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:66:1: item name ends with its containing module's name
-cargo-0.49.0/src/cargo/core/manifest.rs:670:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:693:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:708:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:723:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:726:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:729:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:735:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:738:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:741:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:744:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:747:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:751:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:754:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:757:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:760:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:763:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:767:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:776:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:780:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:787:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:798:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:800:56: redundant closure found
-cargo-0.49.0/src/cargo/core/manifest.rs:805:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:809:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:818:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:823:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:828:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:831:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:834:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:839:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:85:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/core/manifest.rs:888:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/manifest.rs:936:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/package.rs:1075:28: redundant closure found
-cargo-0.49.0/src/cargo/core/package.rs:160:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/package.rs:170:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/package.rs:174:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/package.rs:182:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/package.rs:186:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/package.rs:190:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/package.rs:194:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/package.rs:198:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/package.rs:202:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/package.rs:206:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/package.rs:210:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/package.rs:217:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/package.rs:221:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/package.rs:222:35: redundant closure found
-cargo-0.49.0/src/cargo/core/package.rs:226:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/package.rs:227:35: redundant closure found
-cargo-0.49.0/src/cargo/core/package.rs:230:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/package.rs:239:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/package.rs:249:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/package.rs:287:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/core/package.rs:385:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/package.rs:421:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-cargo-0.49.0/src/cargo/core/package.rs:425:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/package.rs:452:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/package.rs:453:60: redundant closure found
-cargo-0.49.0/src/cargo/core/package.rs:459:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/package.rs:473:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/package.rs:587:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/package.rs:682:46: casting `f64` to `u64` may lose the sign of the value
-cargo-0.49.0/src/cargo/core/package.rs:682:46: casting `f64` to `u64` may truncate the value
-cargo-0.49.0/src/cargo/core/package.rs:682:63: casting `f64` to `u64` may lose the sign of the value
-cargo-0.49.0/src/cargo/core/package.rs:682:63: casting `f64` to `u64` may truncate the value
-cargo-0.49.0/src/cargo/core/package.rs:731:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/package.rs:790:13: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-cargo-0.49.0/src/cargo/core/package.rs:988:9: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-cargo-0.49.0/src/cargo/core/package_id.rs:115:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/package_id.rs:124:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/package_id.rs:139:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/package_id.rs:142:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/package_id.rs:145:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/package_id.rs:149:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/package_id.rs:157:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/package_id.rs:161:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/package_id.rs:169:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/package_id.rs:174:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/core/package_id_spec.rs:101:39: redundant closure found
-cargo-0.49.0/src/cargo/core/package_id_spec.rs:143:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/package_id_spec.rs:147:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/package_id_spec.rs:151:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/package_id_spec.rs:160:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/package_id_spec.rs:179:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/package_id_spec.rs:212:9: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/core/package_id_spec.rs:231:9: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-cargo-0.49.0/src/cargo/core/package_id_spec.rs:51:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/package_id_spec.rs:77:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/package_id_spec.rs:88:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/profiles.rs:1004:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/profiles.rs:1014:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/profiles.rs:1018:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/profiles.rs:1028:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/profiles.rs:106:9: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/core/profiles.rs:143:5: this function's return value is unnecessarily wrapped by `Result`
-cargo-0.49.0/src/cargo/core/profiles.rs:286:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/profiles.rs:294:40: unnecessary boolean `not` operation
-cargo-0.49.0/src/cargo/core/profiles.rs:30:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/profiles.rs:342:25: `maker` is being shadowed
-cargo-0.49.0/src/cargo/core/profiles.rs:370:41: unused `self` argument
-cargo-0.49.0/src/cargo/core/profiles.rs:370:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/profiles.rs:372:9: field assignment outside of initializer for an instance created with Default::default()
-cargo-0.49.0/src/cargo/core/profiles.rs:382:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/profiles.rs:383:28: unnecessary boolean `not` operation
-cargo-0.49.0/src/cargo/core/profiles.rs:397:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/profiles.rs:405:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/profiles.rs:607:1: more than 3 bools in a struct
-cargo-0.49.0/src/cargo/core/profiles.rs:909:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/profiles.rs:923:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/profiles.rs:934:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/profiles.rs:987:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/registry.rs:111:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/registry.rs:127:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/registry.rs:168:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/registry.rs:19:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/registry.rs:240:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/registry.rs:26:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/registry.rs:344:49: redundant closure found
-cargo-0.49.0/src/cargo/core/registry.rs:369:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/registry.rs:424:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/registry.rs:49:1: item name ends with its containing module's name
-cargo-0.49.0/src/cargo/core/registry.rs:520:17: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-cargo-0.49.0/src/cargo/core/registry.rs:763:53: redundant closure found
-cargo-0.49.0/src/cargo/core/registry.rs:765:53: redundant closure found
-cargo-0.49.0/src/cargo/core/registry.rs:807:14: redundant closure found
-cargo-0.49.0/src/cargo/core/registry.rs:814:53: redundant closure found
-cargo-0.49.0/src/cargo/core/resolver/conflict_cache.rs:197:29: redundant closure found
-cargo-0.49.0/src/cargo/core/resolver/conflict_cache.rs:41:38: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
-cargo-0.49.0/src/cargo/core/resolver/context.rs:274:53: redundant closure found
-cargo-0.49.0/src/cargo/core/resolver/context.rs:297:9: called `filter(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/core/resolver/context.rs:42:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/core/resolver/context.rs:74:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/resolver/encode.rs:156:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/resolver/encode.rs:156:5: this function has too many lines (164/100)
-cargo-0.49.0/src/cargo/core/resolver/encode.rs:339:17: wildcard match will miss any future added variants
-cargo-0.49.0/src/cargo/core/resolver/encode.rs:438:5: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/core/resolver/encode.rs:449:5: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/core/resolver/encode.rs:529:34: redundant closure found
-cargo-0.49.0/src/cargo/core/resolver/encode.rs:602:59: redundant closure found
-cargo-0.49.0/src/cargo/core/resolver/encode.rs:623:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/core/resolver/encode.rs:652:27: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-cargo-0.49.0/src/cargo/core/resolver/encode.rs:674:51: redundant closure found
-cargo-0.49.0/src/cargo/core/resolver/errors.rs:103:22: redundant closure found
-cargo-0.49.0/src/cargo/core/resolver/errors.rs:104:22: redundant closure found
-cargo-0.49.0/src/cargo/core/resolver/errors.rs:206:9: unnecessary boolean `not` operation
-cargo-0.49.0/src/cargo/core/resolver/errors.rs:257:45: redundant closure found
-cargo-0.49.0/src/cargo/core/resolver/errors.rs:27:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/resolver/errors.rs:305:17: calling `push_str()` using a single-character string literal
-cargo-0.49.0/src/cargo/core/resolver/errors.rs:70:1: this function has too many lines (207/100)
-cargo-0.49.0/src/cargo/core/resolver/features.rs:104:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/core/resolver/features.rs:111:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/resolver/features.rs:162:56: redundant closure found
-cargo-0.49.0/src/cargo/core/resolver/features.rs:179:1: item name ends with its containing module's name
-cargo-0.49.0/src/cargo/core/resolver/features.rs:186:23: you should put `RequestedFeatures` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/resolver/features.rs:187:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/resolver/features.rs:199:23: you should put `RequestedFeatures` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/resolver/features.rs:200:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/resolver/features.rs:209:9: called `filter(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/core/resolver/features.rs:221:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/resolver/features.rs:231:21: you should put `pkg_id/is_build` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/resolver/features.rs:233:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/resolver/features.rs:247:58: redundant closure found
-cargo-0.49.0/src/cargo/core/resolver/features.rs:278:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/resolver/features.rs:394:27: you should put `FeatureValue` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/resolver/features.rs:460:19: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-cargo-0.49.0/src/cargo/core/resolver/features.rs:480:24: you should put `FeatureValues` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/resolver/features.rs:496:24: you should put `FeatureValues` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/resolver/features.rs:561:28: called `filter(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/core/resolver/features.rs:58:1: item name ends with its containing module's name
-cargo-0.49.0/src/cargo/core/resolver/features.rs:67:1: more than 3 bools in a struct
-cargo-0.49.0/src/cargo/core/resolver/mod.rs:1017:5: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/core/resolver/mod.rs:1045:57: redundant closure found
-cargo-0.49.0/src/cargo/core/resolver/mod.rs:122:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/resolver/mod.rs:142:44: redundant closure found
-cargo-0.49.0/src/cargo/core/resolver/mod.rs:180:1: this function has too many lines (225/100)
-cargo-0.49.0/src/cargo/core/resolver/mod.rs:311:17: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-cargo-0.49.0/src/cargo/core/resolver/mod.rs:421:52: called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find_map(..)` instead.
-cargo-0.49.0/src/cargo/core/resolver/mod.rs:437:33: called `filter(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/core/resolver/mod.rs:457:69: called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find_map(..)` instead.
-cargo-0.49.0/src/cargo/core/resolver/mod.rs:470:37: binding's name is too similar to existing binding
-cargo-0.49.0/src/cargo/core/resolver/mod.rs:480:37: called `filter(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/core/resolver/mod.rs:607:11: this argument is passed by value, but not consumed in the function body
-cargo-0.49.0/src/cargo/core/resolver/mod.rs:631:21: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-cargo-0.49.0/src/cargo/core/resolver/mod.rs:942:15: unnecessary boolean `not` operation
-cargo-0.49.0/src/cargo/core/resolver/mod.rs:988:20: redundant else block
-cargo-0.49.0/src/cargo/core/resolver/resolve.rs:120:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/resolver/resolve.rs:132:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/resolver/resolve.rs:199:24: redundant else block
-cargo-0.49.0/src/cargo/core/resolver/resolve.rs:235:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/resolver/resolve.rs:239:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-cargo-0.49.0/src/cargo/core/resolver/resolve.rs:255:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/resolver/resolve.rs:259:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/resolver/resolve.rs:263:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/resolver/resolve.rs:269:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/resolver/resolve.rs:273:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/resolver/resolve.rs:274:9: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
-cargo-0.49.0/src/cargo/core/resolver/resolve.rs:280:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/resolver/resolve.rs:284:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/resolver/resolve.rs:288:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/resolver/resolve.rs:292:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/resolver/resolve.rs:296:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/resolver/resolve.rs:300:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/resolver/resolve.rs:315:13: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
-cargo-0.49.0/src/cargo/core/resolver/resolve.rs:354:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/resolver/resolve.rs:362:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/resolver/resolve.rs:60:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/core/resolver/resolve.rs:76:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/resolver/resolve.rs:90:35: called `filter(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/core/resolver/types.rs:111:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/resolver/types.rs:121:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/resolver/types.rs:141:19: you should put `ResolveOpts` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/resolver/types.rs:142:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/resolver/types.rs:149:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/resolver/types.rs:181:9: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
-cargo-0.49.0/src/cargo/core/resolver/types.rs:187:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-cargo-0.49.0/src/cargo/core/resolver/types.rs:261:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-cargo-0.49.0/src/cargo/core/shell.rs:113:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/shell.rs:130:9: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-cargo-0.49.0/src/cargo/core/shell.rs:148:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/shell.rs:153:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/shell.rs:163:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/shell.rs:18:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/shell.rs:198:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/shell.rs:206:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/shell.rs:214:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/shell.rs:228:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/shell.rs:239:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/shell.rs:250:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/shell.rs:259:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/shell.rs:267:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/shell.rs:26:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/shell.rs:277:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/shell.rs:282:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/shell.rs:314:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/shell.rs:322:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/shell.rs:330:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/shell.rs:98:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/source/mod.rs:103:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/source/mod.rs:247:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/core/source/mod.rs:261:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/source/mod.rs:268:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/source/mod.rs:273:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/source/mod.rs:291:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/source/mod.rs:302:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/source/mod.rs:307:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/source/mod.rs:31:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/source/mod.rs:37:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/source/mod.rs:39:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/source/mod.rs:47:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/source/mod.rs:50:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/source/mod.rs:52:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/source/mod.rs:63:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/source/mod.rs:74:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/source/mod.rs:83:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/source/source_id.rs:107:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/source/source_id.rs:128:50: redundant closure found
-cargo-0.49.0/src/cargo/core/source/source_id.rs:147:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/source/source_id.rs:156:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/source/source_id.rs:162:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/source/source_id.rs:166:19: you should put `SourceId` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/source/source_id.rs:167:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/source/source_id.rs:171:19: you should put `SourceId` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/source/source_id.rs:172:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/source/source_id.rs:178:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/source/source_id.rs:187:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/source/source_id.rs:18:74: calling `std::sync::Mutex::default()` is more clear than this expression
-cargo-0.49.0/src/cargo/core/source/source_id.rs:195:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/source/source_id.rs:207:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/source/source_id.rs:213:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/source/source_id.rs:217:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/source/source_id.rs:225:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/source/source_id.rs:228:16: use Option::map_or_else instead of an if let/else
-cargo-0.49.0/src/cargo/core/source/source_id.rs:236:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/source/source_id.rs:241:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/source/source_id.rs:252:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/source/source_id.rs:257:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/source/source_id.rs:262:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/source/source_id.rs:305:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/source/source_id.rs:310:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/source/source_id.rs:318:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/source/source_id.rs:326:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/source/source_id.rs:355:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/source/source_id.rs:393:61: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/core/source/source_id.rs:394:42: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/core/source/source_id.rs:395:42: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/core/source/source_id.rs:397:71: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/core/source/source_id.rs:397:71: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/core/source/source_id.rs:398:47: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/core/source/source_id.rs:398:47: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/core/source/source_id.rs:399:47: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/core/source/source_id.rs:399:47: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/core/source/source_id.rs:401:63: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/core/source/source_id.rs:401:63: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/core/source/source_id.rs:401:63: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/core/source/source_id.rs:402:43: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/core/source/source_id.rs:402:43: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/core/source/source_id.rs:402:43: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/core/source/source_id.rs:403:43: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/core/source/source_id.rs:403:43: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/core/source/source_id.rs:403:43: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/core/source/source_id.rs:406:21: usage of wildcard import for enum variants
-cargo-0.49.0/src/cargo/core/source/source_id.rs:412:41: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/core/source/source_id.rs:413:36: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/core/source/source_id.rs:414:36: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/core/source/source_id.rs:420:47: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/core/source/source_id.rs:420:47: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/core/source/source_id.rs:494:42: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/core/source/source_id.rs:512:17: integer type suffix should be separated by an underscore
-cargo-0.49.0/src/cargo/core/source/source_id.rs:513:17: integer type suffix should be separated by an underscore
-cargo-0.49.0/src/cargo/core/source/source_id.rs:517:17: integer type suffix should be separated by an underscore
-cargo-0.49.0/src/cargo/core/source/source_id.rs:518:17: integer type suffix should be separated by an underscore
-cargo-0.49.0/src/cargo/core/source/source_id.rs:525:17: integer type suffix should be separated by an underscore
-cargo-0.49.0/src/cargo/core/source/source_id.rs:526:17: integer type suffix should be separated by an underscore
-cargo-0.49.0/src/cargo/core/source/source_id.rs:530:17: integer type suffix should be separated by an underscore
-cargo-0.49.0/src/cargo/core/source/source_id.rs:531:17: integer type suffix should be separated by an underscore
-cargo-0.49.0/src/cargo/core/source/source_id.rs:535:33: integer type suffix should be separated by an underscore
-cargo-0.49.0/src/cargo/core/source/source_id.rs:536:37: integer type suffix should be separated by an underscore
-cargo-0.49.0/src/cargo/core/source/source_id.rs:537:42: integer type suffix should be separated by an underscore
-cargo-0.49.0/src/cargo/core/source/source_id.rs:538:38: integer type suffix should be separated by an underscore
-cargo-0.49.0/src/cargo/core/source/source_id.rs:548:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/core/source/source_id.rs:597:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/summary.rs:103:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/summary.rs:123:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/summary.rs:150:1: this function has too many lines (141/100)
-cargo-0.49.0/src/cargo/core/summary.rs:158:9: usage of wildcard import for enum variants
-cargo-0.49.0/src/cargo/core/summary.rs:181:21: unnecessary boolean `not` operation
-cargo-0.49.0/src/cargo/core/summary.rs:192:28: redundant else block
-cargo-0.49.0/src/cargo/core/summary.rs:258:32: redundant else block
-cargo-0.49.0/src/cargo/core/summary.rs:281:28: redundant else block
-cargo-0.49.0/src/cargo/core/summary.rs:303:28: redundant else block
-cargo-0.49.0/src/cargo/core/summary.rs:321:51: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/core/summary.rs:344:5: you should put `FeatureValue` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/summary.rs:350:85: you should put `FeatureValue` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/summary.rs:36:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/summary.rs:378:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/summary.rs:386:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/summary.rs:387:13: usage of wildcard import for enum variants
-cargo-0.49.0/src/cargo/core/summary.rs:407:13: usage of wildcard import for enum variants
-cargo-0.49.0/src/cargo/core/summary.rs:69:34: redundant closure found
-cargo-0.49.0/src/cargo/core/summary.rs:75:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/summary.rs:78:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/summary.rs:81:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/summary.rs:84:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/summary.rs:87:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/summary.rs:90:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/summary.rs:93:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/summary.rs:96:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/summary.rs:99:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/workspace.rs:1019:59: called `filter(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/core/workspace.rs:1056:5: this function's return value is unnecessarily wrapped by `Result`
-cargo-0.49.0/src/cargo/core/workspace.rs:113:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/core/workspace.rs:1157:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/core/workspace.rs:128:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/core/workspace.rs:150:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/workspace.rs:159:16: redundant else block
-cargo-0.49.0/src/cargo/core/workspace.rs:197:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/workspace.rs:225:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/workspace.rs:255:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/workspace.rs:267:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/workspace.rs:329:37: you should put `VirtualManifest` between ticks in the documentation
-cargo-0.49.0/src/cargo/core/workspace.rs:410:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/workspace.rs:440:9: this function's return value is unnecessarily wrapped by `Result`
-cargo-0.49.0/src/cargo/core/workspace.rs:511:32: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-cargo-0.49.0/src/cargo/core/workspace.rs:561:25: literal non-ASCII character detected
-cargo-0.49.0/src/cargo/core/workspace.rs:613:13: called `filter_map(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/core/workspace.rs:615:22: redundant closure found
-cargo-0.49.0/src/cargo/core/workspace.rs:688:35: called `filter(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/core/workspace.rs:762:27: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-cargo-0.49.0/src/cargo/core/workspace.rs:784:17: unnecessary boolean `not` operation
-cargo-0.49.0/src/cargo/core/workspace.rs:849:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/workspace.rs:893:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/core/workspace.rs:906:24: redundant else block
-cargo-0.49.0/src/cargo/core/workspace.rs:932:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/lib.rs:177:1: this function could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/lib.rs:180:36: redundant closure found
-cargo-0.49.0/src/cargo/lib.rs:180:36: redundant closure found
-cargo-0.49.0/src/cargo/lib.rs:180:36: redundant closure found
-cargo-0.49.0/src/cargo/lib.rs:180:36: redundant closure found
-cargo-0.49.0/src/cargo/lib.rs:180:36: redundant closure found
-cargo-0.49.0/src/cargo/ops/cargo_clean.rs:205:23: redundant closure found
-cargo-0.49.0/src/cargo/ops/cargo_clean.rs:27:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/cargo_clean.rs:27:1: this function has too many lines (120/100)
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:1078:14: redundant closure found
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:109:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:119:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:1227:17: this argument is passed by value, but not consumed in the function body
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:127:35: usage of `FromIterator::from_iter`
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:128:32: called `filter(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:173:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:205:36: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:242:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:249:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:258:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:275:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:275:1: this function has too many lines (219/100)
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:468:9: calling `std::collections::HashMap::default()` is more clear than this expression
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:548:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:556:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:574:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:583:21: you should put `CompileFilter` between ticks in the documentation
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:584:5: more than 3 bools in function parameters
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:584:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:592:9: binding's name is too similar to existing binding
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:593:9: binding's name is too similar to existing binding
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:607:13: binding's name is too similar to existing binding
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:612:21: you should put `CompileFilter` between ticks in the documentation
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:613:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:618:9: binding's name is too similar to existing binding
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:641:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:652:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:655:50: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:673:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:692:49: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:703:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:729:1: this function has too many lines (205/100)
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:82:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/cargo_compile.rs:874:69: redundant closure found
-cargo-0.49.0/src/cargo/ops/cargo_doc.rs:20:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/cargo_fetch.rs:15:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/cargo_fetch.rs:27:46: redundant closure found
-cargo-0.49.0/src/cargo/ops/cargo_fetch.rs:36:20: called `filter(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/ops/cargo_generate_lockfile.rs:160:5: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/ops/cargo_generate_lockfile.rs:175:5: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/ops/cargo_generate_lockfile.rs:22:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/cargo_generate_lockfile.rs:37:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/cargo_generate_lockfile.rs:37:1: this function has too many lines (171/100)
-cargo-0.49.0/src/cargo/ops/cargo_install.rs:13:5: usage of wildcard import
-cargo-0.49.0/src/cargo/ops/cargo_install.rs:148:1: more than 3 bools in function parameters
-cargo-0.49.0/src/cargo/ops/cargo_install.rs:148:1: this function has too many lines (316/100)
-cargo-0.49.0/src/cargo/ops/cargo_install.rs:202:17: redundant closure found
-cargo-0.49.0/src/cargo/ops/cargo_install.rs:312:64: redundant closure found
-cargo-0.49.0/src/cargo/ops/cargo_install.rs:318:63: called `filter(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/ops/cargo_install.rs:32:13: non-binding `let` on a type that implements `Drop`
-cargo-0.49.0/src/cargo/ops/cargo_install.rs:37:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/cargo_install.rs:454:22: redundant closure found
-cargo-0.49.0/src/cargo/ops/cargo_install.rs:483:5: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/ops/cargo_install.rs:683:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/cargo_new.rs:101:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/cargo_new.rs:245:5: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/ops/cargo_new.rs:251:5: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/ops/cargo_new.rs:367:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/cargo_new.rs:405:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/cargo_new.rs:489:5: you should put `IgnoreList` between ticks in the documentation
-cargo-0.49.0/src/cargo/ops/cargo_new.rs:525:47: you should put `IgnoreList` between ticks in the documentation
-cargo-0.49.0/src/cargo/ops/cargo_new.rs:525:9: you should put `format_existing` between ticks in the documentation
-cargo-0.49.0/src/cargo/ops/cargo_new.rs:572:34: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/ops/cargo_new.rs:623:1: this function has too many lines (130/100)
-cargo-0.49.0/src/cargo/ops/cargo_new.rs:781:5: called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find_map(..)` instead.
-cargo-0.49.0/src/cargo/ops/cargo_new.rs:800:16: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-cargo-0.49.0/src/cargo/ops/cargo_output_metadata.rs:163:36: redundant closure found
-cargo-0.49.0/src/cargo/ops/cargo_output_metadata.rs:27:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/cargo_output_metadata.rs:45:45: redundant closure found
-cargo-0.49.0/src/cargo/ops/cargo_package.rs:144:1: this function has too many lines (112/100)
-cargo-0.49.0/src/cargo/ops/cargo_package.rs:207:13: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-cargo-0.49.0/src/cargo/ops/cargo_package.rs:25:1: more than 3 bools in a struct
-cargo-0.49.0/src/cargo/ops/cargo_package.rs:307:54: redundant closure found
-cargo-0.49.0/src/cargo/ops/cargo_package.rs:394:5: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/ops/cargo_package.rs:418:21: called `filter(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/ops/cargo_package.rs:425:61: redundant closure found
-cargo-0.49.0/src/cargo/ops/cargo_package.rs:459:5: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/ops/cargo_package.rs:66:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/cargo_package.rs:769:29: called `filter(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/ops/cargo_package.rs:93:20: unnecessary boolean `not` operation
-cargo-0.49.0/src/cargo/ops/cargo_pkgid.rs:5:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/cargo_read_manifest.rs:14:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/cargo_read_manifest.rs:171:5: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/ops/cargo_read_manifest.rs:37:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/cargo_read_manifest.rs:57:49: redundant closure found
-cargo-0.49.0/src/cargo/ops/cargo_read_manifest.rs:69:37: redundant closure found
-cargo-0.49.0/src/cargo/ops/cargo_run.rs:25:24: unnecessary boolean `not` operation
-cargo-0.49.0/src/cargo/ops/cargo_run.rs:35:9: unnecessary boolean `not` operation
-cargo-0.49.0/src/cargo/ops/cargo_run.rs:37:16: redundant else block
-cargo-0.49.0/src/cargo/ops/cargo_run.rs:53:9: unnecessary boolean `not` operation
-cargo-0.49.0/src/cargo/ops/cargo_run.rs:65:16: redundant else block
-cargo-0.49.0/src/cargo/ops/cargo_run.rs:9:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/cargo_test.rs:16:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/cargo_test.rs:43:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/cargo_test.rs:84:17: binding's name is too similar to existing binding
-cargo-0.49.0/src/cargo/ops/cargo_uninstall.rs:14:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/cargo_uninstall.rs:7:5: usage of wildcard import
-cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:147:9: you should put `PackageId` between ticks in the documentation
-cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:233:21: calling `push_str()` using a single-character string literal
-cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:244:22: you should put `PackageId` between ticks in the documentation
-cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:244:63: you should put `PackageId` between ticks in the documentation
-cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:253:17: unnecessary boolean `not` operation
-cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:370:5: this function's return value is unnecessarily wrapped by `Result`
-cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:392:9: called `find(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:505:8: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
-cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:525:10: this argument is passed by value, but not consumed in the function body
-cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:542:27: redundant closure found
-cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:542:5: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:561:20: redundant else block
-cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:613:5: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:645:41: you should put `BTreeSet` between ticks in the documentation
-cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:654:42: called `filter(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:662:14: called `filter(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:674:17: called `filter(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:681:17: called `filter(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:92:19: you should put `InstallTracker` between ticks in the documentation
-cargo-0.49.0/src/cargo/ops/fix.rs:200:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/fix.rs:200:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/ops/fix.rs:424:20: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
-cargo-0.49.0/src/cargo/ops/fix.rs:455:13: binding's name is too similar to existing binding
-cargo-0.49.0/src/cargo/ops/fix.rs:506:17: binding's name is too similar to existing binding
-cargo-0.49.0/src/cargo/ops/fix.rs:608:9: field assignment outside of initializer for an instance created with Default::default()
-cargo-0.49.0/src/cargo/ops/fix.rs:612:42: redundant closure found
-cargo-0.49.0/src/cargo/ops/fix.rs:619:48: stripping a prefix manually
-cargo-0.49.0/src/cargo/ops/fix.rs:66:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/ops/fix.rs:66:1: more than 3 bools in a struct
-cargo-0.49.0/src/cargo/ops/fix.rs:708:18: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/ops/fix.rs:77:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/lockfile.rs:154:13: calling `push_str()` using a single-character string literal
-cargo-0.49.0/src/cargo/ops/lockfile.rs:217:9: calling `push_str()` using a single-character string literal
-cargo-0.49.0/src/cargo/ops/lockfile.rs:30:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/lockfile.rs:35:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/lockfile.rs:35:1: item name ends with its containing module's name
-cargo-0.49.0/src/cargo/ops/lockfile.rs:87:1: this function's return value is unnecessarily wrapped by `Result`
-cargo-0.49.0/src/cargo/ops/lockfile.rs:8:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/lockfile.rs:8:1: item name ends with its containing module's name
-cargo-0.49.0/src/cargo/ops/registry.rs:150:21: redundant closure found
-cargo-0.49.0/src/cargo/ops/registry.rs:188:1: this function has too many lines (130/100)
-cargo-0.49.0/src/cargo/ops/registry.rs:196:16: called `filter(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/ops/registry.rs:212:32: unnecessary `!=` operation
-cargo-0.49.0/src/cargo/ops/registry.rs:222:53: redundant closure found
-cargo-0.49.0/src/cargo/ops/registry.rs:224:44: redundant closure found
-cargo-0.49.0/src/cargo/ops/registry.rs:31:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/ops/registry.rs:346:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/registry.rs:346:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/ops/registry.rs:351:26: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-cargo-0.49.0/src/cargo/ops/registry.rs:385:12: this argument is passed by value, but not consumed in the function body
-cargo-0.49.0/src/cargo/ops/registry.rs:386:15: this argument is passed by value, but not consumed in the function body
-cargo-0.49.0/src/cargo/ops/registry.rs:38:1: more than 3 bools in a struct
-cargo-0.49.0/src/cargo/ops/registry.rs:477:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/registry.rs:483:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/registry.rs:503:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/registry.rs:505:38: calling `util::config::CargoHttpConfig::default()` is more clear than this expression
-cargo-0.49.0/src/cargo/ops/registry.rs:510:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/registry.rs:529:5: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/ops/registry.rs:53:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/registry.rs:573:22: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/ops/registry.rs:608:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/registry.rs:621:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/registry.rs:671:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/registry.rs:671:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/ops/registry.rs:674:10: this argument is passed by value, but not consumed in the function body
-cargo-0.49.0/src/cargo/ops/registry.rs:678:17: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-cargo-0.49.0/src/cargo/ops/registry.rs:730:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/registry.rs:731:16: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-cargo-0.49.0/src/cargo/ops/registry.rs:785:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/registry.rs:794:16: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-cargo-0.49.0/src/cargo/ops/registry.rs:828:14: you should put `SourceId` between ticks in the documentation
-cargo-0.49.0/src/cargo/ops/registry.rs:848:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/resolve.rs:199:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/resolve.rs:199:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/ops/resolve.rs:199:1: this function has too many lines (137/100)
-cargo-0.49.0/src/cargo/ops/resolve.rs:241:28: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-cargo-0.49.0/src/cargo/ops/resolve.rs:28:1: item name ends with its containing module's name
-cargo-0.49.0/src/cargo/ops/resolve.rs:384:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/resolve.rs:417:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/resolve.rs:589:9: `keep` is being shadowed
-cargo-0.49.0/src/cargo/ops/resolve.rs:58:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/resolve.rs:58:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/ops/resolve.rs:602:5: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/ops/resolve.rs:75:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/resolve.rs:75:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/ops/tree/graph.rs:129:26: you should put `PackageIds` between ticks in the documentation
-cargo-0.49.0/src/cargo/ops/tree/graph.rs:131:47: called `filter(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/ops/tree/graph.rs:152:15: indexing into a vector may panic
-cargo-0.49.0/src/cargo/ops/tree/graph.rs:173:9: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/ops/tree/graph.rs:234:46: called `filter(..).flat_map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/ops/tree/graph.rs:328:44: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/ops/tree/graph.rs:330:50: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/ops/tree/graph.rs:563:35: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-cargo-0.49.0/src/cargo/ops/tree/mod.rs:112:11: literal non-ASCII character detected
-cargo-0.49.0/src/cargo/ops/tree/mod.rs:113:10: literal non-ASCII character detected
-cargo-0.49.0/src/cargo/ops/tree/mod.rs:114:10: literal non-ASCII character detected
-cargo-0.49.0/src/cargo/ops/tree/mod.rs:115:12: literal non-ASCII character detected
-cargo-0.49.0/src/cargo/ops/tree/mod.rs:126:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/tree/mod.rs:21:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/ops/tree/mod.rs:21:1: more than 3 bools in a struct
-cargo-0.49.0/src/cargo/ops/tree/mod.rs:360:30: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/ops/tree/mod.rs:58:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/ops/vendor.rs:14:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/ops/vendor.rs:21:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/ops/vendor.rs:314:34: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/ops/vendor.rs:324:13: wildcard match will miss any future added variants
-cargo-0.49.0/src/cargo/ops/vendor.rs:70:1: this function has too many lines (175/100)
-cargo-0.49.0/src/cargo/sources/config.rs:102:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/sources/config.rs:135:67: redundant closure found
-cargo-0.49.0/src/cargo/sources/config.rs:206:36: this argument is passed by value, but not consumed in the function body
-cargo-0.49.0/src/cargo/sources/config.rs:282:9: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/sources/config.rs:70:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/sources/config.rs:81:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/sources/config.rs:97:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/sources/directory.rs:14:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/sources/directory.rs:90:56: redundant closure found
-cargo-0.49.0/src/cargo/sources/git/source.rs:14:1: item name ends with its containing module's name
-cargo-0.49.0/src/cargo/sources/git/source.rs:25:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/sources/git/source.rs:49:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/sources/git/source.rs:53:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/sources/git/source.rs:69:20: comparison to empty slice
-cargo-0.49.0/src/cargo/sources/git/utils.rs:1025:19: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-cargo-0.49.0/src/cargo/sources/git/utils.rs:1158:9: stripping a suffix manually
-cargo-0.49.0/src/cargo/sources/git/utils.rs:176:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/sources/git/utils.rs:180:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/sources/git/utils.rs:184:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/sources/git/utils.rs:188:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/sources/git/utils.rs:242:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/sources/git/utils.rs:253:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/sources/git/utils.rs:262:13: unnecessary boolean `not` operation
-cargo-0.49.0/src/cargo/sources/git/utils.rs:289:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/sources/git/utils.rs:294:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/sources/git/utils.rs:298:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/sources/git/utils.rs:308:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/sources/git/utils.rs:472:9: non-binding `let` on a type that implements `Drop`
-cargo-0.49.0/src/cargo/sources/git/utils.rs:489:9: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/sources/git/utils.rs:503:9: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/sources/git/utils.rs:528:28: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-cargo-0.49.0/src/cargo/sources/git/utils.rs:537:21: non-binding `let` on a type that implements `Drop`
-cargo-0.49.0/src/cargo/sources/git/utils.rs:588:1: this function has too many lines (135/100)
-cargo-0.49.0/src/cargo/sources/git/utils.rs:758:9: calling `push_str()` using a single-character string literal
-cargo-0.49.0/src/cargo/sources/git/utils.rs:858:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/sources/path.rs:129:44: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/sources/path.rs:143:44: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/sources/path.rs:15:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/sources/path.rs:282:50: redundant closure found
-cargo-0.49.0/src/cargo/sources/path.rs:313:21: binding's name is too similar to existing binding
-cargo-0.49.0/src/cargo/sources/path.rs:314:21: binding's name is too similar to existing binding
-cargo-0.49.0/src/cargo/sources/path.rs:319:21: binding's name is too similar to existing binding
-cargo-0.49.0/src/cargo/sources/path.rs:339:9: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/sources/path.rs:339:9: this function's return value is unnecessarily wrapped by `Result`
-cargo-0.49.0/src/cargo/sources/path.rs:380:9: unused `self` argument
-cargo-0.49.0/src/cargo/sources/path.rs:419:50: redundant closure found
-cargo-0.49.0/src/cargo/sources/path.rs:429:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/sources/path.rs:460:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/sources/path.rs:473:43: redundant closure found
-cargo-0.49.0/src/cargo/sources/path.rs:482:43: redundant closure found
-cargo-0.49.0/src/cargo/sources/path.rs:63:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/sources/path.rs:77:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/sources/path.rs:98:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/sources/registry/index.rs:117:23: integer type suffix should be separated by an underscore
-cargo-0.49.0/src/cargo/sources/registry/index.rs:121:70: integer type suffix should be separated by an underscore
-cargo-0.49.0/src/cargo/sources/registry/index.rs:167:1: item name ends with its containing module's name
-cargo-0.49.0/src/cargo/sources/registry/index.rs:215:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/sources/registry/index.rs:324:23: redundant closure found
-cargo-0.49.0/src/cargo/sources/registry/index.rs:393:25: called `filter(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/sources/registry/index.rs:468:40: you should put `SourceId` between ticks in the documentation
-cargo-0.49.0/src/cargo/sources/registry/index.rs:590:9: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/sources/registry/index.rs:648:17: binding's name is too similar to existing binding
-cargo-0.49.0/src/cargo/sources/registry/index.rs:736:1: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-cargo-0.49.0/src/cargo/sources/registry/index.rs:95:37: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-cargo-0.49.0/src/cargo/sources/registry/local.rs:12:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/sources/registry/mod.rs:192:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/sources/registry/mod.rs:203:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/sources/registry/mod.rs:229:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/sources/registry/mod.rs:372:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/sources/registry/mod.rs:373:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/sources/registry/mod.rs:375:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/sources/registry/mod.rs:381:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/sources/registry/mod.rs:382:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/sources/registry/mod.rs:383:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/sources/registry/mod.rs:384:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/sources/registry/mod.rs:452:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/sources/registry/mod.rs:582:20: redundant else block
-cargo-0.49.0/src/cargo/sources/registry/mod.rs:621:9: unnecessary `!=` operation
-cargo-0.49.0/src/cargo/sources/registry/remote.rs:139:17: unused `self` argument
-cargo-0.49.0/src/cargo/sources/registry/remote.rs:32:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/sources/registry/remote.rs:72:13: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-cargo-0.49.0/src/cargo/sources/replaced.rs:12:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/sources/replaced.rs:5:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/util/canonical_url.rs:19:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/canonical_url.rs:65:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/command_prelude.rs:218:1: this function could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/command_prelude.rs:222:1: this function could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/command_prelude.rs:234:1: this function could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/command_prelude.rs:249:1: this function could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/command_prelude.rs:264:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/command_prelude.rs:279:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/command_prelude.rs:298:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/command_prelude.rs:320:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/command_prelude.rs:328:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/command_prelude.rs:352:13: unnecessary boolean `not` operation
-cargo-0.49.0/src/cargo/util/command_prelude.rs:363:13: unnecessary boolean `not` operation
-cargo-0.49.0/src/cargo/util/command_prelude.rs:378:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/command_prelude.rs:387:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/command_prelude.rs:387:5: this function has too many lines (104/100)
-cargo-0.49.0/src/cargo/util/command_prelude.rs:39:20: you should put `arg_package_spec` between ticks in the documentation
-cargo-0.49.0/src/cargo/util/command_prelude.rs:504:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/command_prelude.rs:516:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/command_prelude.rs:530:40: redundant closure found
-cargo-0.49.0/src/cargo/util/command_prelude.rs:531:43: redundant closure found
-cargo-0.49.0/src/cargo/util/command_prelude.rs:536:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/command_prelude.rs:556:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/command_prelude.rs:575:49: redundant closure found
-cargo-0.49.0/src/cargo/util/command_prelude.rs:580:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/command_prelude.rs:631:18: redundant closure found
-cargo-0.49.0/src/cargo/util/command_prelude.rs:638:18: redundant closure found
-cargo-0.49.0/src/cargo/util/command_prelude.rs:647:1: this function could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/command_prelude.rs:651:1: this function could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/command_prelude.rs:662:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/command_prelude.rs:665:51: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/util/config/de.rs:420:16: this argument is passed by value, but not consumed in the function body
-cargo-0.49.0/src/cargo/util/config/de.rs:46:25: you should put `CV::List` between ticks in the documentation
-cargo-0.49.0/src/cargo/util/config/de.rs:47:24: you should put `ConfigSeqAccess` between ticks in the documentation
-cargo-0.49.0/src/cargo/util/config/de.rs:527:53: integer type suffix should be separated by an underscore
-cargo-0.49.0/src/cargo/util/config/de.rs:530:53: integer type suffix should be separated by an underscore
-cargo-0.49.0/src/cargo/util/config/de.rs:532:68: integer type suffix should be separated by an underscore
-cargo-0.49.0/src/cargo/util/config/key.rs:11:1: item name ends with its containing module's name
-cargo-0.49.0/src/cargo/util/config/key.rs:69:9: calling `push_str()` using a single-character string literal
-cargo-0.49.0/src/cargo/util/config/mod.rs:100:71: you should put `OptValue` between ticks in the documentation
-cargo-0.49.0/src/cargo/util/config/mod.rs:100:71: you should put `OptValue` between ticks in the documentation
-cargo-0.49.0/src/cargo/util/config/mod.rs:100:71: you should put `OptValue` between ticks in the documentation
-cargo-0.49.0/src/cargo/util/config/mod.rs:1049:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:1064:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:1090:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:1166:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:1179:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:1184:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:1189:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:1203:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:1211:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:1216:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:1225:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:1229:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:124:1: more than 3 bools in a struct
-cargo-0.49.0/src/cargo/util/config/mod.rs:1254:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:1279:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:1281:9: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-cargo-0.49.0/src/cargo/util/config/mod.rs:1323:9: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/util/config/mod.rs:1339:39: unused `self` argument
-cargo-0.49.0/src/cargo/util/config/mod.rs:1344:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/util/config/mod.rs:1420:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/util/config/mod.rs:1553:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:1560:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:1567:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:1574:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:1581:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:1588:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/config/mod.rs:1598:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/config/mod.rs:1619:1: this function could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/config/mod.rs:1623:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:1623:64: this argument is passed by value, but not consumed in the function body
-cargo-0.49.0/src/cargo/util/config/mod.rs:1649:9: use Option::map_or_else instead of an if let/else
-cargo-0.49.0/src/cargo/util/config/mod.rs:1699:5: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/util/config/mod.rs:1730:1: item name ends with its containing module's name
-cargo-0.49.0/src/cargo/util/config/mod.rs:1757:1: item name ends with its containing module's name
-cargo-0.49.0/src/cargo/util/config/mod.rs:1770:1: item name ends with its containing module's name
-cargo-0.49.0/src/cargo/util/config/mod.rs:1778:1: item name ends with its containing module's name
-cargo-0.49.0/src/cargo/util/config/mod.rs:1804:1: item name ends with its containing module's name
-cargo-0.49.0/src/cargo/util/config/mod.rs:1896:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/config/mod.rs:1901:5: you should put `StringList` between ticks in the documentation
-cargo-0.49.0/src/cargo/util/config/mod.rs:214:13: wildcard match will miss any future added variants
-cargo-0.49.0/src/cargo/util/config/mod.rs:259:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:298:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:311:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:318:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:353:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:401:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:411:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:419:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:431:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:449:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:454:16: use Option::map_or instead of an if let/else
-cargo-0.49.0/src/cargo/util/config/mod.rs:547:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:556:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:582:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:595:20: you should put `StringList` between ticks in the documentation
-cargo-0.49.0/src/cargo/util/config/mod.rs:689:20: unused `self` argument
-cargo-0.49.0/src/cargo/util/config/mod.rs:699:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:699:5: more than 3 bools in function parameters
-cargo-0.49.0/src/cargo/util/config/mod.rs:719:58: redundant closure found
-cargo-0.49.0/src/cargo/util/config/mod.rs:816:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/config/mod.rs:875:36: binding's name is too similar to existing binding
-cargo-0.49.0/src/cargo/util/config/mod.rs:876:37: binding's name is too similar to existing binding
-cargo-0.49.0/src/cargo/util/config/path.rs:10:1: item name ends with its containing module's name
-cargo-0.49.0/src/cargo/util/config/path.rs:14:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/config/path.rs:48:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/util/config/target.rs:12:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/util/config/target.rs:24:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/util/config/value.rs:29:1: item name ends with its containing module's name
-cargo-0.49.0/src/cargo/util/config/value.rs:80:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/config/value.rs:81:9: match expression looks like `matches!` macro
-cargo-0.49.0/src/cargo/util/cpu.rs:11:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/cpu.rs:22:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/cpu.rs:82:25: casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-cargo-0.49.0/src/cargo/util/cpu.rs:82:9: casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-cargo-0.49.0/src/cargo/util/dependency_queue.rs:109:27: redundant closure found
-cargo-0.49.0/src/cargo/util/dependency_queue.rs:136:20: called `filter(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/util/dependency_queue.rs:151:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/dependency_queue.rs:156:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/dependency_queue.rs:46:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/dependency_queue.rs:91:9: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/util/diagnostic_server.rs:218:1: item name ends with its containing module's name
-cargo-0.49.0/src/cargo/util/diagnostic_server.rs:230:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/diagnostic_server.rs:242:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/diagnostic_server.rs:58:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/diagnostic_server.rs:96:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/diagnostic_server.rs:96:5: this function has too many lines (110/100)
-cargo-0.49.0/src/cargo/util/diagnostic_server.rs:99:21: `msg` is being shadowed
-cargo-0.49.0/src/cargo/util/errors.rs:101:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/errors.rs:143:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/errors.rs:150:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/errors.rs:15:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/errors.rs:237:5: variant name ends with the enum's name
-cargo-0.49.0/src/cargo/util/errors.rs:245:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/errors.rs:321:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/errors.rs:328:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/errors.rs:356:1: this function could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/errors.rs:391:5: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/util/errors.rs:392:13: usage of wildcard import
-cargo-0.49.0/src/cargo/util/errors.rs:465:1: this function could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/errors.rs:473:5: manual `RangeInclusive::contains` implementation
-cargo-0.49.0/src/cargo/util/errors.rs:66:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/flock.rs:115:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/flock.rs:11:5: usage of wildcard import
-cargo-0.49.0/src/cargo/util/flock.rs:134:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/flock.rs:142:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/flock.rs:150:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/flock.rs:156:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/flock.rs:170:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/flock.rs:192:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/flock.rs:29:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/flock.rs:321:5: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/util/flock.rs:335:23: casting `i64` to `u32` may lose the sign of the value
-cargo-0.49.0/src/cargo/util/flock.rs:335:23: casting `i64` to `u32` may truncate the value
-cargo-0.49.0/src/cargo/util/flock.rs:335:44: casting `i64` to `u32` may truncate the value
-cargo-0.49.0/src/cargo/util/flock.rs:379:35: this `match` has identical arm bodies
-cargo-0.49.0/src/cargo/util/flock.rs:37:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/flock.rs:43:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/flock.rs:52:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/graph.rs:10:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/graph.rs:115:13: called `find(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/util/graph.rs:41:51: redundant closure found
-cargo-0.49.0/src/cargo/util/graph.rs:45:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/graph.rs:95:13: called `find(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/util/hasher.rs:12:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/hasher.rs:9:1: item name ends with its containing module's name
-cargo-0.49.0/src/cargo/util/hex.rs:10:9: casting `u64` to `u8` may truncate the value
-cargo-0.49.0/src/cargo/util/hex.rs:11:9: casting `u64` to `u8` may truncate the value
-cargo-0.49.0/src/cargo/util/hex.rs:12:9: casting `u64` to `u8` may truncate the value
-cargo-0.49.0/src/cargo/util/hex.rs:13:9: casting `u64` to `u8` may truncate the value
-cargo-0.49.0/src/cargo/util/hex.rs:14:9: casting `u64` to `u8` may truncate the value
-cargo-0.49.0/src/cargo/util/hex.rs:15:9: casting `u64` to `u8` may truncate the value
-cargo-0.49.0/src/cargo/util/hex.rs:25:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/hex.rs:6:1: item name ends with its containing module's name
-cargo-0.49.0/src/cargo/util/hex.rs:6:1: this function could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/hex.rs:8:9: casting `u64` to `u8` may truncate the value
-cargo-0.49.0/src/cargo/util/hex.rs:9:9: casting `u64` to `u8` may truncate the value
-cargo-0.49.0/src/cargo/util/important_paths.rs:23:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/important_paths.rs:6:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/interning.rs:66:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/interning.rs:77:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/into_url.rs:10:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/into_url_with_base.rs:9:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/job.rs:20:1: this function could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/lev_distance.rs:3:1: this function could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/lockserver.rs:111:32: redundant else block
-cargo-0.49.0/src/cargo/util/lockserver.rs:158:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/lockserver.rs:46:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/lockserver.rs:58:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/lockserver.rs:62:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/mod.rs:68:1: this function could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/mod.rs:79:1: this function could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/network.rs:12:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/network.rs:19:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/network.rs:84:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/paths.rs:109:12: redundant else block
-cargo-0.49.0/src/cargo/util/paths.rs:114:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/paths.rs:121:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/paths.rs:125:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/paths.rs:130:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/paths.rs:14:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/paths.rs:14:1: item name ends with its containing module's name
-cargo-0.49.0/src/cargo/util/paths.rs:151:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/paths.rs:167:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/paths.rs:173:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/paths.rs:178:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/paths.rs:185:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/paths.rs:199:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/paths.rs:215:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/paths.rs:228:1: this function could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/paths.rs:251:9: use Option::map_or instead of an if let/else
-cargo-0.49.0/src/cargo/util/paths.rs:267:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/paths.rs:276:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/paths.rs:29:1: this function could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/paths.rs:303:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/paths.rs:312:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/paths.rs:346:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/paths.rs:415:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/paths.rs:445:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/paths.rs:459:45: redundant closure found
-cargo-0.49.0/src/cargo/util/paths.rs:469:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/paths.rs:54:1: this function could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/paths.rs:61:1: this function could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/paths.rs:63:19: use Option::map_or_else instead of an if let/else
-cargo-0.49.0/src/cargo/util/paths.rs:88:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/paths.rs:93:31: comparison to empty slice
-cargo-0.49.0/src/cargo/util/process_builder.rs:106:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/process_builder.rs:111:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/process_builder.rs:122:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/process_builder.rs:132:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/process_builder.rs:152:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/process_builder.rs:185:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/process_builder.rs:190:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/process_builder.rs:218:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/process_builder.rs:307:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/process_builder.rs:343:39: this argument is passed by value, but not consumed in the function body
-cargo-0.49.0/src/cargo/util/progress.rs:122:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/progress.rs:136:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/progress.rs:15:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/util/progress.rs:249:19: casting `usize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`usize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-cargo-0.49.0/src/cargo/util/progress.rs:249:34: casting `usize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`usize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-cargo-0.49.0/src/cargo/util/progress.rs:250:19: unnecessary boolean `not` operation
-cargo-0.49.0/src/cargo/util/progress.rs:263:22: casting `usize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`usize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-cargo-0.49.0/src/cargo/util/progress.rs:264:22: casting `f64` to `usize` may lose the sign of the value
-cargo-0.49.0/src/cargo/util/progress.rs:264:22: casting `f64` to `usize` may truncate the value
-cargo-0.49.0/src/cargo/util/progress.rs:269:17: calling `push_str()` using a single-character string literal
-cargo-0.49.0/src/cargo/util/progress.rs:272:17: calling `push_str()` using a single-character string literal
-cargo-0.49.0/src/cargo/util/progress.rs:274:17: calling `push_str()` using a single-character string literal
-cargo-0.49.0/src/cargo/util/progress.rs:280:13: calling `push_str()` using a single-character string literal
-cargo-0.49.0/src/cargo/util/progress.rs:282:9: calling `push_str()` using a single-character string literal
-cargo-0.49.0/src/cargo/util/progress.rs:89:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/progress.rs:97:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/queue.rs:25:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/read2.rs:11:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/read2.rs:31:17: binding's name is too similar to existing binding
-cargo-0.49.0/src/cargo/util/restricted_names.rs:13:1: this function could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/restricted_names.rs:26:1: this function could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/restricted_names.rs:35:1: this function could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/restricted_names.rs:45:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/restricted_names.rs:87:1: this function could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/restricted_names.rs:89:21: redundant closure found
-cargo-0.49.0/src/cargo/util/restricted_names.rs:8:1: this function could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/rustc.rs:103:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/rustc.rs:114:5: you should put bare URLs between `<`/`>` or make a proper Markdown link
-cargo-0.49.0/src/cargo/util/rustc.rs:115:5: you should put bare URLs between `<`/`>` or make a proper Markdown link
-cargo-0.49.0/src/cargo/util/rustc.rs:162:17: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/util/rustc.rs:39:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/rustc.rs:55:13: called `find(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/util/sha256.rs:10:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/sha256.rs:20:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/sha256.rs:31:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/sha256.rs:40:24: integer type suffix should be separated by an underscore
-cargo-0.49.0/src/cargo/util/to_semver.rs:5:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/toml/mod.rs:1005:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/toml/mod.rs:1005:5: this function has too many lines (282/100)
-cargo-0.49.0/src/cargo/util/toml/mod.rs:1094:36: redundant closure found
-cargo-0.49.0/src/cargo/util/toml/mod.rs:1121:13: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/util/toml/mod.rs:1197:32: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
-cargo-0.49.0/src/cargo/util/toml/mod.rs:124:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/toml/mod.rs:1504:9: unused `self` argument
-cargo-0.49.0/src/cargo/util/toml/mod.rs:1526:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/toml/mod.rs:1582:19: calling `util::toml::DetailedTomlDependency::default()` is more clear than this expression
-cargo-0.49.0/src/cargo/util/toml/mod.rs:1598:5: this function has too many lines (153/100)
-cargo-0.49.0/src/cargo/util/toml/mod.rs:1687:33: unnecessary closure used to substitute value for `Option::None`
-cargo-0.49.0/src/cargo/util/toml/mod.rs:178:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/util/toml/mod.rs:248:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/util/toml/mod.rs:274:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/util/toml/mod.rs:277:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/toml/mod.rs:281:5: this method could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/toml/mod.rs:285:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/toml/mod.rs:294:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/util/toml/mod.rs:31:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/toml/mod.rs:381:35: casting `i64` to `u32` may lose the sign of the value
-cargo-0.49.0/src/cargo/util/toml/mod.rs:381:35: casting `i64` to `u32` may truncate the value
-cargo-0.49.0/src/cargo/util/toml/mod.rs:388:35: casting `u64` to `u32` may truncate the value
-cargo-0.49.0/src/cargo/util/toml/mod.rs:398:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/util/toml/mod.rs:450:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/toml/mod.rs:536:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/toml/mod.rs:783:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/util/toml/mod.rs:824:1: item name starts with its containing module's name
-cargo-0.49.0/src/cargo/util/toml/mod.rs:834:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/toml/mod.rs:83:42: redundant closure found
-cargo-0.49.0/src/cargo/util/toml/mod.rs:852:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/toml/mod.rs:852:5: this function has too many lines (138/100)
-cargo-0.49.0/src/cargo/util/toml/mod.rs:962:9: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/util/toml/mod.rs:971:24: called `filter(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/util/toml/mod.rs:979:9: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/util/toml/mod.rs:98:5: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/util/toml/mod.rs:999:23: calling `util::toml::DetailedTomlDependency::default()` is more clear than this expression
-cargo-0.49.0/src/cargo/util/toml/targets.rs:112:27: redundant closure found
-cargo-0.49.0/src/cargo/util/toml/targets.rs:325:5: adding items after statements is confusing, since items exist from the start of the scope
-cargo-0.49.0/src/cargo/util/toml/targets.rs:586:21: redundant closure found
-cargo-0.49.0/src/cargo/util/toml/targets.rs:593:42: redundant closure found
-cargo-0.49.0/src/cargo/util/toml/targets.rs:605:19: redundant closure found
-cargo-0.49.0/src/cargo/util/toml/targets.rs:612:42: redundant closure found
-cargo-0.49.0/src/cargo/util/toml/targets.rs:756:36: redundant closure found
-cargo-0.49.0/src/cargo/util/toml/targets.rs:810:24: called `filter(..).map(..)` on an `Iterator`
-cargo-0.49.0/src/cargo/util/vcs.rs:10:1: this function could have a `#[must_use]` attribute
-cargo-0.49.0/src/cargo/util/vcs.rs:33:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/vcs.rs:37:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/vcs.rs:43:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/vcs.rs:47:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/vcs.rs:59:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/vcs.rs:66:5: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/workspace.rs:52:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/workspace.rs:56:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/workspace.rs:60:1: docs for function returning `Result` missing `# Errors` section
-cargo-0.49.0/src/cargo/util/workspace.rs:64:1: docs for function returning `Result` missing `# Errors` section
-iron-0.6.1/src/error.rs:24:1: item name ends with its containing module's name
-iron-0.6.1/src/error.rs:55:20: use of deprecated associated function `std::error::Error::description`: use the Display impl or to_string()
-iron-0.6.1/src/iron.rs:105:13: redundant field names in struct initialization
-iron-0.6.1/src/iron.rs:119:5: docs for function returning `Result` missing `# Errors` section
-iron-0.6.1/src/iron.rs:133:5: docs for function returning `Result` missing `# Errors` section
-iron-0.6.1/src/iron.rs:143:5: docs for function returning `Result` missing `# Errors` section
-iron-0.6.1/src/iron.rs:148:19: use of deprecated macro `try`: use the `?` operator instead
-iron-0.6.1/src/iron.rs:149:13: redundant field names in struct initialization
-iron-0.6.1/src/iron.rs:167:49: binding's name is too similar to existing binding
-iron-0.6.1/src/iron.rs:80:5: this method could have a `#[must_use]` attribute
-iron-0.6.1/src/iron.rs:85:5: this method could have a `#[must_use]` attribute
-iron-0.6.1/src/iron.rs:90:5: this method could have a `#[must_use]` attribute
-iron-0.6.1/src/middleware/mod.rs:137:5: docs for function returning `Result` missing `# Errors` section
-iron-0.6.1/src/middleware/mod.rs:150:1: item name ends with its containing module's name
-iron-0.6.1/src/middleware/mod.rs:152:5: docs for function returning `Result` missing `# Errors` section
-iron-0.6.1/src/middleware/mod.rs:159:5: docs for function returning `Result` missing `# Errors` section
-iron-0.6.1/src/middleware/mod.rs:171:1: item name ends with its containing module's name
-iron-0.6.1/src/middleware/mod.rs:173:5: docs for function returning `Result` missing `# Errors` section
-iron-0.6.1/src/middleware/mod.rs:182:5: docs for function returning `Result` missing `# Errors` section
-iron-0.6.1/src/middleware/mod.rs:192:1: item name ends with its containing module's name
-iron-0.6.1/src/middleware/mod.rs:217:25: you should put `ChainBuilder` between ticks in the documentation
-iron-0.6.1/src/middleware/mod.rs:328:20: binding's name is too similar to existing binding
-iron-0.6.1/src/middleware/mod.rs:360:16: binding's name is too similar to existing binding
-iron-0.6.1/src/middleware/mod.rs:368:33: binding's name is too similar to existing binding
-iron-0.6.1/src/middleware/mod.rs:428:40: binding's name is too similar to existing binding
-iron-0.6.1/src/middleware/mod.rs:434:40: binding's name is too similar to existing binding
-iron-0.6.1/src/middleware/mod.rs:444:40: binding's name is too similar to existing binding
-iron-0.6.1/src/modifiers.rs:132:14: use of `expect` followed by a function call
-iron-0.6.1/src/request/mod.rs:113:24: binding's name is too similar to existing binding
-iron-0.6.1/src/request/mod.rs:121:13: redundant field names in struct initialization
-iron-0.6.1/src/request/mod.rs:123:13: redundant field names in struct initialization
-iron-0.6.1/src/request/mod.rs:124:13: redundant field names in struct initialization
-iron-0.6.1/src/request/mod.rs:126:13: redundant field names in struct initialization
-iron-0.6.1/src/request/mod.rs:128:13: redundant field names in struct initialization
-iron-0.6.1/src/request/mod.rs:153:69: you should put `HttpReader` between ticks in the documentation
-iron-0.6.1/src/request/mod.rs:154:5: this method could have a `#[must_use]` attribute
-iron-0.6.1/src/request/mod.rs:32:1: this seems like a manual implementation of the non-exhaustive pattern
-iron-0.6.1/src/request/mod.rs:62:9: use of deprecated macro `try`: use the `?` operator instead
-iron-0.6.1/src/request/mod.rs:64:9: use of deprecated macro `try`: use the `?` operator instead
-iron-0.6.1/src/request/mod.rs:65:9: use of deprecated macro `try`: use the `?` operator instead
-iron-0.6.1/src/request/mod.rs:66:9: use of deprecated macro `try`: use the `?` operator instead
-iron-0.6.1/src/request/mod.rs:67:9: use of deprecated macro `try`: use the `?` operator instead
-iron-0.6.1/src/request/mod.rs:69:9: use of deprecated macro `try`: use the `?` operator instead
-iron-0.6.1/src/request/mod.rs:75:34: you should put `HttpRequest` between ticks in the documentation
-iron-0.6.1/src/request/mod.rs:77:39: you should put `HttpRequest` between ticks in the documentation
-iron-0.6.1/src/request/mod.rs:78:5: docs for function returning `Result` missing `# Errors` section
-iron-0.6.1/src/request/mod.rs:82:13: binding's name is too similar to existing binding
-iron-0.6.1/src/request/mod.rs:83:29: binding's name is too similar to existing binding
-iron-0.6.1/src/request/mod.rs:85:24: binding's name is too similar to existing binding
-iron-0.6.1/src/request/url.rs:109:5: this method could have a `#[must_use]` attribute
-iron-0.6.1/src/request/url.rs:117:5: this method could have a `#[must_use]` attribute
-iron-0.6.1/src/request/url.rs:124:9: use of deprecated macro `try`: use the `?` operator instead
-iron-0.6.1/src/request/url.rs:129:1: an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true
-iron-0.6.1/src/request/url.rs:21:14: you should put bare URLs between `<`/`>` or make a proper Markdown link
-iron-0.6.1/src/request/url.rs:22:5: docs for function returning `Result` missing `# Errors` section
-iron-0.6.1/src/request/url.rs:31:5: docs for function returning `Result` missing `# Errors` section
-iron-0.6.1/src/request/url.rs:47:5: this method could have a `#[must_use]` attribute
-iron-0.6.1/src/request/url.rs:52:5: this method could have a `#[must_use]` attribute
-iron-0.6.1/src/request/url.rs:57:5: this method could have a `#[must_use]` attribute
-iron-0.6.1/src/request/url.rs:63:5: this method could have a `#[must_use]` attribute
-iron-0.6.1/src/request/url.rs:73:5: this method could have a `#[must_use]` attribute
-iron-0.6.1/src/request/url.rs:83:5: this method could have a `#[must_use]` attribute
-iron-0.6.1/src/request/url.rs:96:5: this method could have a `#[must_use]` attribute
-iron-0.6.1/src/response.rs:121:19: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-iron-0.6.1/src/response.rs:125:43: redundant closure found
-iron-0.6.1/src/response.rs:139:41: redundant closure found
-iron-0.6.1/src/response.rs:142:23: use of deprecated macro `try`: use the `?` operator instead
-iron-0.6.1/src/response.rs:143:5: use of deprecated macro `try`: use the `?` operator instead
-iron-0.6.1/src/response.rs:24:5: docs for function returning `Result` missing `# Errors` section
-iron-0.6.1/src/response.rs:95:5: this method could have a `#[must_use]` attribute
-iron-0.6.1/src/response.rs:95:5: you should consider adding a `Default` implementation for `response::Response`
-libc-0.2.81/build.rs:114:19: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
-libc-0.2.81/build.rs:124:5: this block may be rewritten with the `?` operator
-libc-0.2.81/build.rs:133:5: this block may be rewritten with the `?` operator
-libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/macros.rs:243:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/macros.rs:243:17: unsafe function's docs miss `# Safety` section
-libc-0.2.81/src/macros.rs:243:17: unsafe function's docs miss `# Safety` section
-libc-0.2.81/src/macros.rs:243:17: unsafe function's docs miss `# Safety` section
-libc-0.2.81/src/macros.rs:259:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/macros.rs:259:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/macros.rs:259:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/macros.rs:259:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/macros.rs:259:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/macros.rs:259:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/macros.rs:259:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/macros.rs:259:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/macros.rs:259:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/macros.rs:259:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/macros.rs:259:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/macros.rs:259:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/macros.rs:259:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/macros.rs:259:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/macros.rs:259:17: this function could have a `#[must_use]` attribute
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:428:29: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:429:30: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:431:30: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:432:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:433:29: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:434:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:595:33: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:596:33: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:597:35: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:622:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:673:34: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:696:33: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:697:35: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:698:33: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:699:35: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:712:34: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:721:35: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:722:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:723:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:751:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:752:30: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:753:30: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:754:30: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:755:29: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:756:29: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:757:29: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:758:29: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:759:29: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:760:29: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:768:30: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:769:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:771:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:772:29: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:773:29: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:774:29: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:775:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:776:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:777:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:778:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:779:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:780:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:781:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:782:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:783:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:784:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:785:33: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:786:33: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:787:30: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:788:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:789:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:790:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:791:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:792:33: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:794:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:795:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:796:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:797:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:798:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:799:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:800:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:801:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:803:27: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:804:28: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:805:28: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:806:29: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:807:29: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:808:29: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:809:29: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:810:29: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:811:29: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:812:30: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:813:30: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:814:30: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:815:30: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:816:30: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:817:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:818:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:821:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:822:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:823:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:824:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:825:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:826:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:827:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:828:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:829:33: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:830:33: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:831:33: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:832:33: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:833:33: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:834:33: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:835:33: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:836:33: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:841:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:842:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:843:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:844:33: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:1120:38: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:178:34: integer type suffix should be separated by an underscore
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:291:5: this method could have a `#[must_use]` attribute
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:291:5: unsafe function's docs miss `# Safety` section
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:302:5: this method could have a `#[must_use]` attribute
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:302:5: unsafe function's docs miss `# Safety` section
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:355:13: this method could have a `#[must_use]` attribute
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:355:13: unsafe function's docs miss `# Safety` section
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:359:13: this method could have a `#[must_use]` attribute
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:359:13: unsafe function's docs miss `# Safety` section
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:363:13: this method could have a `#[must_use]` attribute
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:363:13: unsafe function's docs miss `# Safety` section
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:367:13: this method could have a `#[must_use]` attribute
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:367:13: unsafe function's docs miss `# Safety` section
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:371:13: this method could have a `#[must_use]` attribute
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:371:13: unsafe function's docs miss `# Safety` section
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:534:36: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:645:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:727:40: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:728:40: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:729:39: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:731:44: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:732:36: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:733:41: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:734:43: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:735:42: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:736:40: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:737:36: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:738:37: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:741:39: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:742:40: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:743:40: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:744:40: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:745:40: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:746:43: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:747:42: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:748:40: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:749:39: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:750:41: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:751:41: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:752:43: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:753:42: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:755:42: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:756:41: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:757:41: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:758:39: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:759:39: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:761:41: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:762:44: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:763:45: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:764:40: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:765:40: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:766:40: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:767:44: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:768:44: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:769:39: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:770:35: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:771:35: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:772:37: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:773:39: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:774:45: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:775:41: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:776:39: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:803:34: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:841:30: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:842:37: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:982:40: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:984:46: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1209:36: casting `i32` to `i16` may truncate the value
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1210:36: casting `i32` to `i16` may truncate the value
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1235:39: integer type suffix should be separated by an underscore
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1236:41: integer type suffix should be separated by an underscore
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1274:42: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1324:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1333:37: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1334:35: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1346:34: casting `u32` to `i32` may wrap around the value
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1346:34: integer type suffix should be separated by an underscore
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1346:34: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1347:37: casting `u32` to `i32` may wrap around the value
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1347:37: integer type suffix should be separated by an underscore
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1347:37: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1348:36: casting `u32` to `i32` may wrap around the value
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1348:36: integer type suffix should be separated by an underscore
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1348:36: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1349:37: casting `u32` to `i32` may wrap around the value
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1349:37: integer type suffix should be separated by an underscore
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1349:37: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1350:35: casting `u32` to `i32` may wrap around the value
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1350:35: integer type suffix should be separated by an underscore
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1350:35: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1351:36: casting `u32` to `i32` may wrap around the value
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1351:36: integer type suffix should be separated by an underscore
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1351:36: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1352:31: casting `u32` to `i32` may wrap around the value
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1352:31: integer type suffix should be separated by an underscore
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1352:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1419:36: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1420:36: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1421:36: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1422:36: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1423:36: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1490:37: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1561:46: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1562:45: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1567:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1568:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1586:26: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1587:34: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1588:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1589:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1897:38: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1898:51: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1900:39: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1969:34: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1970:34: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1971:36: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1972:36: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1973:36: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1974:37: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1975:37: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1976:36: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1977:36: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1978:39: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1979:39: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1980:39: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1981:39: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1982:39: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1983:39: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1984:38: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1985:38: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1986:35: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1987:35: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1988:35: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1989:35: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1990:38: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1991:37: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1992:37: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1993:38: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1994:37: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1995:37: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1996:37: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1997:37: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1998:33: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:1999:33: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2000:33: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2001:34: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2002:34: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2003:34: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2004:35: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2005:35: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2032:30: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2033:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2034:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2035:29: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2036:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2037:28: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2038:27: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2039:29: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2041:29: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2042:28: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2043:27: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2044:34: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2045:27: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2046:33: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2048:28: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2049:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2050:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2051:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2052:26: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2053:36: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2318:42: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2321:38: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2331:39: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2487:42: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2488:42: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2489:43: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2490:43: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2491:43: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2493:47: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2494:44: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2495:46: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2496:47: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2497:49: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2498:48: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2499:50: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2500:45: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2572:9: unneeded `return` statement
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2578:20: `0 as *mut _` detected
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2588:13: `0 as *mut _` detected
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2596:52: used binding `_dummy` which is prefixed with an underscore. A leading underscore signals that a binding will not be used.
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2597:11: casting `i32` to `usize` may lose the sign of the value
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2601:21: it is more concise to loop over references to containers instead of using explicit iteration methods
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2611:9: unneeded unit expression
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2619:9: unneeded unit expression
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2634:9: casting `u32` to `i32` may wrap around the value
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2647:25: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2648:25: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2649:9: casting `u64` to `u32` may truncate the value
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2654:18: the operation is ineffective. Consider reducing it to `(dev & 0x00000000000000ff)`
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2654:25: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2655:25: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2656:9: casting `u64` to `u32` may truncate the value
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2660:21: casting `u32` to `u64` may become silently lossy if you later change the type
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2661:21: casting `u32` to `u64` may become silently lossy if you later change the type
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2663:25: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2664:25: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2665:16: the operation is ineffective. Consider reducing it to `(minor & 0x000000ff)`
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2665:25: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:2666:25: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:40:1: enum with no variants
-libc-0.2.81/src/unix/linux_like/linux/mod.rs:954:34: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1000:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1001:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1002:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1016:29: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1017:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1018:33: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1019:33: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1020:33: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1029:29: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1030:29: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1031:30: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1032:29: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1033:29: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1034:29: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1035:29: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1041:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1042:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1043:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1044:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1045:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1046:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1047:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1048:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1049:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1050:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1051:33: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1053:29: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1054:33: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1055:30: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1056:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1057:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1058:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1059:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1060:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1073:42: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1074:43: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1075:37: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1076:37: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1077:41: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1078:35: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1079:35: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1080:36: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1081:35: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1082:35: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1083:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1084:38: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1086:30: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1087:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1089:30: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1090:33: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1091:30: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1094:40: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1095:37: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1096:41: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1097:40: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1098:39: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1099:34: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1100:36: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1101:38: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1102:37: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1105:44: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1106:41: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1107:42: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1108:42: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1109:41: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1110:46: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1111:41: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1112:44: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1113:40: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1114:47: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1115:36: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1126:34: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1127:29: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1128:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1179:32: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1180:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:1218:27: the operation is ineffective. Consider reducing it to `IPOPT_CONTROL`
-libc-0.2.81/src/unix/linux_like/mod.rs:1314:9: operator precedence can trip the unwary
-libc-0.2.81/src/unix/linux_like/mod.rs:1323:13: `0 as *mut _` detected
-libc-0.2.81/src/unix/linux_like/mod.rs:1332:9: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-libc-0.2.81/src/unix/linux_like/mod.rs:1337:9: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-libc-0.2.81/src/unix/linux_like/mod.rs:1341:18: casting `i32` to `usize` may lose the sign of the value
-libc-0.2.81/src/unix/linux_like/mod.rs:1344:9: unneeded `return` statement
-libc-0.2.81/src/unix/linux_like/mod.rs:1348:18: casting `i32` to `usize` may lose the sign of the value
-libc-0.2.81/src/unix/linux_like/mod.rs:1350:9: unneeded `return` statement
-libc-0.2.81/src/unix/linux_like/mod.rs:1354:18: casting `i32` to `usize` may lose the sign of the value
-libc-0.2.81/src/unix/linux_like/mod.rs:1357:9: unneeded `return` statement
-libc-0.2.81/src/unix/linux_like/mod.rs:1361:21: it is more concise to loop over references to containers instead of using explicit iteration methods
-libc-0.2.81/src/unix/linux_like/mod.rs:1381:9: casting `i32` to `i8` may truncate the value
-libc-0.2.81/src/unix/linux_like/mod.rs:1389:9: bit mask could be simplified with a call to `trailing_zeros`
-libc-0.2.81/src/unix/linux_like/mod.rs:446:31: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:591:36: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:592:38: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:593:35: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:594:33: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:595:34: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:596:36: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:597:37: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:598:37: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:599:39: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:600:34: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:601:35: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:602:35: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:607:37: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:608:35: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:764:35: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:765:39: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:991:30: long literal lacking separators
-libc-0.2.81/src/unix/linux_like/mod.rs:9:1: enum with no variants
-libc-0.2.81/src/unix/mod.rs:198:29: long literal lacking separators
-libc-0.2.81/src/unix/mod.rs:199:28: long literal lacking separators
-libc-0.2.81/src/unix/mod.rs:201:35: casting integer literal to `usize` is unnecessary
-libc-0.2.81/src/unix/mod.rs:202:35: casting integer literal to `usize` is unnecessary
-libc-0.2.81/src/unix/mod.rs:282:40: long literal lacking separators
-libc-0.2.81/src/unix/mod.rs:284:41: long literal lacking separators
-libc-0.2.81/src/unix/mod.rs:285:36: long literal lacking separators
-libc-0.2.81/src/unix/mod.rs:34:1: enum with no variants
-libc-0.2.81/src/unix/mod.rs:386:1: enum with no variants
-libc-0.2.81/src/unix/mod.rs:394:1: enum with no variants
-log-0.4.11/src/lib.rs:1047:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:1053:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:1059:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:1093:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:1093:5: you should consider adding a `Default` implementation for `MetadataBuilder<'a>`
-log-0.4.11/src/lib.rs:1118:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:1177:1: you have declared `#[inline(always)]` on `max_level`. This is usually a bad idea
-log-0.4.11/src/lib.rs:1178:1: this function could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:1306:1: docs for function returning `Result` missing `# Errors` section
-log-0.4.11/src/lib.rs:1358:1: this function could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:1359:5: unnecessary `!=` operation
-log-0.4.11/src/lib.rs:1407:1: this function could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:329:27: you are deriving `Hash` but have implemented `PartialEq` explicitly
-log-0.4.11/src/lib.rs:356:1: you are implementing `Clone` explicitly on a `Copy` type
-log-0.4.11/src/lib.rs:448:12: manual `RangeInclusive::contains` implementation
-log-0.4.11/src/lib.rs:468:13: called `filter(..).map(..)` on an `Iterator`
-log-0.4.11/src/lib.rs:500:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:506:28: this argument (8 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-log-0.4.11/src/lib.rs:506:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:520:27: you are deriving `Hash` but have implemented `PartialEq` explicitly
-log-0.4.11/src/lib.rs:538:1: you are implementing `Clone` explicitly on a `Copy` type
-log-0.4.11/src/lib.rs:653:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:661:21: this argument (8 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-log-0.4.11/src/lib.rs:661:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:677:44: this `match` has identical arm bodies
-log-0.4.11/src/lib.rs:758:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:764:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:770:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:776:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:782:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:788:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:794:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:803:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:809:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:818:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:908:5: this method could have a `#[must_use]` attribute
-log-0.4.11/src/lib.rs:908:5: you should consider adding a `Default` implementation for `RecordBuilder<'a>`
-log-0.4.11/src/lib.rs:995:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/detection.rs:2:5: usage of wildcard import
-proc-macro2-1.0.24/src/fallback.rs:108:17: wildcard match will miss any future added variants
-proc-macro2-1.0.24/src/fallback.rs:269:20: unused `self` argument
-proc-macro2-1.0.24/src/fallback.rs:430:24: this argument (0 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-proc-macro2-1.0.24/src/fallback.rs:437:23: this argument (0 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-proc-macro2-1.0.24/src/fallback.rs:437:23: unused `self` argument
-proc-macro2-1.0.24/src/fallback.rs:471:17: this argument (0 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-proc-macro2-1.0.24/src/fallback.rs:471:17: unused `self` argument
-proc-macro2-1.0.24/src/fallback.rs:654:5: manual `RangeInclusive::contains` implementation
-proc-macro2-1.0.24/src/fallback.rs:655:12: manual `RangeInclusive::contains` implementation
-proc-macro2-1.0.24/src/fallback.rs:661:5: manual `RangeInclusive::contains` implementation
-proc-macro2-1.0.24/src/fallback.rs:662:12: manual `RangeInclusive::contains` implementation
-proc-macro2-1.0.24/src/fallback.rs:664:12: manual `RangeInclusive::contains` implementation
-proc-macro2-1.0.24/src/fallback.rs:674:37: manual `RangeInclusive::contains` implementation
-proc-macro2-1.0.24/src/fallback.rs:678:5: adding items after statements is confusing, since items exist from the start of the scope
-proc-macro2-1.0.24/src/fallback.rs:85:9: adding items after statements is confusing, since items exist from the start of the scope
-proc-macro2-1.0.24/src/fallback.rs:882:43: unused `self` argument
-proc-macro2-1.0.24/src/lib.rs:1017:9: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:1081:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:1099:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:1117:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:1135:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:1141:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:1146:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:1151:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:1156:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:152:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:157:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:373:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:383:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:397:24: this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-proc-macro2-1.0.24/src/lib.rs:397:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:403:23: this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-proc-macro2-1.0.24/src/lib.rs:403:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:418:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:425:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:464:17: this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-proc-macro2-1.0.24/src/lib.rs:500:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:626:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:633:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:641:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:652:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:662:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:672:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:734:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:743:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:752:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:757:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:788:19: you should put `XID_Start` between ticks in the documentation
-proc-macro2-1.0.24/src/lib.rs:788:69: you should put `XID_Continue` between ticks in the documentation
-proc-macro2-1.0.24/src/lib.rs:891:36: you should put `syn::parse_str` between ticks in the documentation
-proc-macro2-1.0.24/src/lib.rs:894:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:911:5: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/lib.rs:996:9: this method could have a `#[must_use]` attribute
-proc-macro2-1.0.24/src/parse.rs:552:5: this loop could be written as a `for` loop
-proc-macro2-1.0.24/src/parse.rs:584:21: manual `RangeInclusive::contains` implementation
-proc-macro2-1.0.24/src/parse.rs:602:20: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
-proc-macro2-1.0.24/src/parse.rs:696:29: casting `u8` to `u64` may become silently lossy if you later change the type
-proc-macro2-1.0.24/src/parse.rs:702:34: casting `u8` to `u64` may become silently lossy if you later change the type
-proc-macro2-1.0.24/src/parse.rs:708:34: casting `u8` to `u64` may become silently lossy if you later change the type
-proc-macro2-1.0.24/src/parse.rs:803:15: it is more concise to loop over references to containers instead of using explicit iteration methods
-proc-macro2-1.0.24/src/parse.rs:808:15: it is more concise to loop over references to containers instead of using explicit iteration methods
-proc-macro2-1.0.24/src/wrapper.rs:415:24: this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-proc-macro2-1.0.24/src/wrapper.rs:429:23: this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-proc-macro2-1.0.24/src/wrapper.rs:492:17: this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-quote-1.0.7/src/ext.rs:10:1: item name ends with its containing module's name
-quote-1.0.7/src/ext.rs:7:5: you should put `TokenStream` between ticks in the documentation
-quote-1.0.7/src/ident_fragment.rs:13:5: docs for function returning `Result` missing `# Errors` section
-quote-1.0.7/src/ident_fragment.rs:51:31: stripping a prefix manually
-quote-1.0.7/src/runtime.rs:52:5: item name ends with its containing module's name
-quote-1.0.7/src/runtime.rs:63:5: item name ends with its containing module's name
-quote-1.0.7/src/runtime.rs:66:33: you should put `DoesNotHaveIter` between ticks in the documentation
-quote-1.0.7/src/runtime.rs:80:5: item name ends with its containing module's name
-rand-0.7.3/src/distributions/bernoulli.rs:103:20: casting `f64` to `u64` may lose the sign of the value
-rand-0.7.3/src/distributions/bernoulli.rs:103:20: casting `f64` to `u64` may truncate the value
-rand-0.7.3/src/distributions/bernoulli.rs:116:5: docs for function returning `Result` missing `# Errors` section
-rand-0.7.3/src/distributions/bernoulli.rs:123:21: casting `f64` to `u64` may lose the sign of the value
-rand-0.7.3/src/distributions/bernoulli.rs:123:21: casting `f64` to `u64` may truncate the value
-rand-0.7.3/src/distributions/bernoulli.rs:63:26: casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/bernoulli.rs:63:27: integer type suffix should be separated by an underscore
-rand-0.7.3/src/distributions/bernoulli.rs:67:1: item name starts with its containing module's name
-rand-0.7.3/src/distributions/bernoulli.rs:95:5: docs for function returning `Result` missing `# Errors` section
-rand-0.7.3/src/distributions/bernoulli.rs:96:13: manual `Range::contains` implementation
-rand-0.7.3/src/distributions/binomial.rs:107:23: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/binomial.rs:112:44: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/binomial.rs:116:13: adding items after statements is confusing, since items exist from the start of the scope
-rand-0.7.3/src/distributions/binomial.rs:150:28: redundant else block
-rand-0.7.3/src/distributions/binomial.rs:153:24: unnecessary boolean `not` operation
-rand-0.7.3/src/distributions/binomial.rs:158:28: redundant else block
-rand-0.7.3/src/distributions/binomial.rs:164:33: casting `i64` to `u64` may lose the sign of the value
-rand-0.7.3/src/distributions/binomial.rs:166:28: redundant else block
-rand-0.7.3/src/distributions/binomial.rs:175:47: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/binomial.rs:185:38: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/binomial.rs:194:38: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/binomial.rs:202:28: redundant else block
-rand-0.7.3/src/distributions/binomial.rs:209:25: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/binomial.rs:221:26: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/binomial.rs:222:26: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/binomial.rs:223:25: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/binomial.rs:224:25: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/binomial.rs:226:17: adding items after statements is confusing, since items exist from the start of the scope
-rand-0.7.3/src/distributions/binomial.rs:233:32: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/binomial.rs:234:27: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/binomial.rs:251:22: casting `i64` to `u64` may lose the sign of the value
-rand-0.7.3/src/distributions/binomial.rs:255:9: unnecessary `!=` operation
-rand-0.7.3/src/distributions/binomial.rs:35:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/distributions/binomial.rs:45:17: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/binomial.rs:46:5: casting `f64` to `i64` may truncate the value
-rand-0.7.3/src/distributions/binomial.rs:50:5: this function has too many lines (143/100)
-rand-0.7.3/src/distributions/binomial.rs:76:9: adding items after statements is confusing, since items exist from the start of the scope
-rand-0.7.3/src/distributions/binomial.rs:78:12: casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/binomial.rs:81:21: casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/binomial.rs:82:32: casting `u64` to `i32` may truncate the value
-rand-0.7.3/src/distributions/binomial.rs:88:26: casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/binomial.rs:99:21: casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/distributions/cauchy.rs:33:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/distributions/dirichlet.rs:52:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/distributions/dirichlet.rs:64:32: float type suffix should be separated by an underscore
-rand-0.7.3/src/distributions/dirichlet.rs:65:23: float type suffix should be separated by an underscore
-rand-0.7.3/src/distributions/exponential.rs:76:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/distributions/float.rs:73:1: item name ends with its containing module's name
-rand-0.7.3/src/distributions/gamma.rs:13:5: usage of wildcard import for enum variants
-rand-0.7.3/src/distributions/gamma.rs:14:5: usage of wildcard import for enum variants
-rand-0.7.3/src/distributions/gamma.rs:189:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/distributions/gamma.rs:230:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/distributions/gamma.rs:259:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/distributions/gamma.rs:287:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/distributions/gamma.rs:90:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/distributions/integer.rs:23:9: casting `u32` to `u8` may truncate the value
-rand-0.7.3/src/distributions/integer.rs:30:9: casting `u32` to `u16` may truncate the value
-rand-0.7.3/src/distributions/integer.rs:69:9: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
-rand-0.7.3/src/distributions/mod.rs:263:5: you have declared `#[inline(always)]` on `next`. This is usually a bad idea
-rand-0.7.3/src/distributions/normal.rs:100:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/distributions/normal.rs:119:1: item name ends with its containing module's name
-rand-0.7.3/src/distributions/normal.rs:131:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/distributions/normal.rs:31:1: item name ends with its containing module's name
-rand-0.7.3/src/distributions/normal.rs:47:25: float type suffix should be separated by an underscore
-rand-0.7.3/src/distributions/normal.rs:48:25: float type suffix should be separated by an underscore
-rand-0.7.3/src/distributions/other.rs:89:9: casting `u32` to `i32` may wrap around the value
-rand-0.7.3/src/distributions/pareto.rs:32:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/distributions/poisson.rs:35:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/distributions/poisson.rs:87:30: casting `f64` to `u64` may lose the sign of the value
-rand-0.7.3/src/distributions/poisson.rs:87:30: casting `f64` to `u64` may truncate the value
-rand-0.7.3/src/distributions/triangular.rs:32:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/distributions/uniform.rs:146:4: needless `fn main` in doctest
-rand-0.7.3/src/distributions/uniform.rs:199:1: item name ends with its containing module's name
-rand-0.7.3/src/distributions/uniform.rs:214:1: item name starts with its containing module's name
-rand-0.7.3/src/distributions/uniform.rs:283:14: you should put `SampleUniform` between ticks in the documentation
-rand-0.7.3/src/distributions/uniform.rs:283:46: you should put `SampleUniform` between ticks in the documentation
-rand-0.7.3/src/distributions/uniform.rs:296:5: you have declared `#[inline(always)]` on `borrow`. This is usually a bad idea
-rand-0.7.3/src/distributions/uniform.rs:304:5: you have declared `#[inline(always)]` on `borrow`. This is usually a bad idea
-rand-0.7.3/src/distributions/uniform.rs:350:1: item name starts with its containing module's name
-rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
-rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
-rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
-rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
-rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
-rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
-rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
-rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
-rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
-rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
-rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
-rand-0.7.3/src/distributions/uniform.rs:407:21: redundant field names in struct initialization
-rand-0.7.3/src/distributions/uniform.rs:441:31: because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false
-rand-0.7.3/src/distributions/uniform.rs:441:31: because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false
-rand-0.7.3/src/distributions/uniform.rs:441:31: because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false
-rand-0.7.3/src/distributions/uniform.rs:441:31: because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false
-rand-0.7.3/src/distributions/uniform.rs:441:31: because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false
-rand-0.7.3/src/distributions/uniform.rs:441:31: because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false
-rand-0.7.3/src/distributions/uniform.rs:441:31: because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false
-rand-0.7.3/src/distributions/uniform.rs:441:31: because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false
-rand-0.7.3/src/distributions/uniform.rs:56:10: you should put `SampleBorrow` between ticks in the documentation
-rand-0.7.3/src/distributions/uniform.rs:647:1: item name starts with its containing module's name
-rand-0.7.3/src/distributions/uniform.rs:840:1: item name starts with its containing module's name
-rand-0.7.3/src/distributions/uniform.rs:913:13: use Option::map_or_else instead of an if let/else
-rand-0.7.3/src/distributions/uniform.rs:943:54: casting `u64` to `u32` may truncate the value
-rand-0.7.3/src/distributions/unit_circle.rs:30:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/distributions/unit_sphere.rs:24:1: item name starts with its containing module's name
-rand-0.7.3/src/distributions/unit_sphere.rs:29:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/distributions/utils.rs:247:15: methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name
-rand-0.7.3/src/distributions/utils.rs:248:20: methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name
-rand-0.7.3/src/distributions/utils.rs:249:18: methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name
-rand-0.7.3/src/distributions/utils.rs:254:5: you have declared `#[inline(always)]` on `lanes`. This is usually a bad idea
-rand-0.7.3/src/distributions/utils.rs:258:5: you have declared `#[inline(always)]` on `splat`. This is usually a bad idea
-rand-0.7.3/src/distributions/utils.rs:262:5: you have declared `#[inline(always)]` on `extract`. This is usually a bad idea
-rand-0.7.3/src/distributions/utils.rs:267:5: you have declared `#[inline(always)]` on `replace`. This is usually a bad idea
-rand-0.7.3/src/distributions/utils.rs:281:5: you have declared `#[inline(always)]` on `any`. This is usually a bad idea
-rand-0.7.3/src/distributions/utils.rs:286:5: you have declared `#[inline(always)]` on `all`. This is usually a bad idea
-rand-0.7.3/src/distributions/utils.rs:291:5: you have declared `#[inline(always)]` on `none`. This is usually a bad idea
-rand-0.7.3/src/distributions/utils.rs:488:17: you should put `x_i` between ticks in the documentation
-rand-0.7.3/src/distributions/utils.rs:489:50: you should put `x_i` between ticks in the documentation
-rand-0.7.3/src/distributions/utils.rs:489:63: you should put `f(x_i` between ticks in the documentation
-rand-0.7.3/src/distributions/utils.rs:490:40: you should put `f(x_i` between ticks in the documentation
-rand-0.7.3/src/distributions/utils.rs:490:49: you should put `f(x_{i+1` between ticks in the documentation
-rand-0.7.3/src/distributions/utils.rs:518:17: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
-rand-0.7.3/src/distributions/weibull.rs:29:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/distributions/weighted/alias_method.rs:113:21: it is more concise to loop over references to containers instead of using explicit iteration methods
-rand-0.7.3/src/distributions/weighted/alias_method.rs:125:9: adding items after statements is confusing, since items exist from the start of the scope
-rand-0.7.3/src/distributions/weighted/alias_method.rs:131:9: adding items after statements is confusing, since items exist from the start of the scope
-rand-0.7.3/src/distributions/weighted/alias_method.rs:180:36: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-rand-0.7.3/src/distributions/weighted/alias_method.rs:182:34: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-rand-0.7.3/src/distributions/weighted/alias_method.rs:259:28: using `clone` on type `distributions::uniform::Uniform<u32>` which implements the `Copy` trait
-rand-0.7.3/src/distributions/weighted/alias_method.rs:296:9: you are using an explicit closure for copying elements
-rand-0.7.3/src/distributions/weighted/alias_method.rs:321:9: you are using an explicit closure for copying elements
-rand-0.7.3/src/distributions/weighted/alias_method.rs:78:5: docs for function returning `Result` missing `# Errors` section
-rand-0.7.3/src/distributions/weighted/alias_method.rs:78:5: this function has too many lines (106/100)
-rand-0.7.3/src/distributions/weighted/alias_method.rs:85:17: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-rand-0.7.3/src/distributions/weighted/alias_method.rs:87:31: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
-rand-0.7.3/src/distributions/weighted/mod.rs:100:5: docs for function returning `Result` missing `# Errors` section
-rand-0.7.3/src/distributions/weighted/mod.rs:144:5: docs for function returning `Result` missing `# Errors` section
-rand-0.7.3/src/distributions/weighted/mod.rs:169:16: unnecessary `>= y + 1` or `x - 1 >=`
-rand-0.7.3/src/distributions/weighted/mod.rs:386:1: item name starts with its containing module's name
-rand-0.7.3/src/distributions/weighted/mod.rs:85:1: item name starts with its containing module's name
-rand-0.7.3/src/lib.rs:333:5: docs for function returning `Result` missing `# Errors` section
-rand-0.7.3/src/lib.rs:404:14: methods called `to_*` usually take self by reference; consider choosing a less ambiguous name
-rand-0.7.3/src/lib.rs:552:1: this function could have a `#[must_use]` attribute
-rand-0.7.3/src/rngs/adapter/read.rs:47:1: item name starts with its containing module's name
-rand-0.7.3/src/rngs/adapter/read.rs:89:1: item name starts with its containing module's name
-rand-0.7.3/src/rngs/adapter/reseeding.rs:100:5: docs for function returning `Result` missing `# Errors` section
-rand-0.7.3/src/rngs/adapter/reseeding.rs:112:5: you have declared `#[inline(always)]` on `next_u32`. This is usually a bad idea
-rand-0.7.3/src/rngs/adapter/reseeding.rs:117:5: you have declared `#[inline(always)]` on `next_u64`. This is usually a bad idea
-rand-0.7.3/src/rngs/adapter/reseeding.rs:198:13: casting `u64` to `i64` may wrap around the value
-rand-0.7.3/src/rngs/adapter/reseeding.rs:231:9: casting `usize` to `isize` may wrap around the value
-rand-0.7.3/src/rngs/adapter/reseeding.rs:27:28: you should put `ChaCha` between ticks in the documentation
-rand-0.7.3/src/rngs/adapter/reseeding.rs:79:1: item name starts with its containing module's name
-rand-0.7.3/src/rngs/entropy.rs:24:1: item name starts with its containing module's name
-rand-0.7.3/src/rngs/entropy.rs:34:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/rngs/mock.rs:36:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/rngs/mock.rs:47:9: casting `u64` to `u32` may truncate the value
-rand-0.7.3/src/rngs/mod.rs:61:74: you should put `ChaCha20` between ticks in the documentation
-rand-0.7.3/src/rngs/std.rs:25:39: you should put `ChaCha` between ticks in the documentation
-rand-0.7.3/src/rngs/std.rs:32:10: you should put `rand_chacha` between ticks in the documentation
-rand-0.7.3/src/rngs/std.rs:36:1: item name starts with its containing module's name
-rand-0.7.3/src/rngs/std.rs:39:5: you have declared `#[inline(always)]` on `next_u32`. This is usually a bad idea
-rand-0.7.3/src/rngs/std.rs:44:5: you have declared `#[inline(always)]` on `next_u64`. This is usually a bad idea
-rand-0.7.3/src/rngs/std.rs:49:5: you have declared `#[inline(always)]` on `fill_bytes`. This is usually a bad idea
-rand-0.7.3/src/rngs/std.rs:54:5: you have declared `#[inline(always)]` on `try_fill_bytes`. This is usually a bad idea
-rand-0.7.3/src/rngs/std.rs:63:5: you have declared `#[inline(always)]` on `from_seed`. This is usually a bad idea
-rand-0.7.3/src/rngs/std.rs:68:5: you have declared `#[inline(always)]` on `from_rng`. This is usually a bad idea
-rand-0.7.3/src/rngs/thread.rs:57:1: item name starts with its containing module's name
-rand-0.7.3/src/rngs/thread.rs:80:1: item name starts with its containing module's name
-rand-0.7.3/src/rngs/thread.rs:80:1: this function could have a `#[must_use]` attribute
-rand-0.7.3/src/rngs/thread.rs:81:35: redundant closure found
-rand-0.7.3/src/rngs/thread.rs:93:5: you have declared `#[inline(always)]` on `next_u32`. This is usually a bad idea
-rand-0.7.3/src/rngs/thread.rs:98:5: you have declared `#[inline(always)]` on `next_u64`. This is usually a bad idea
-rand-0.7.3/src/seq/index.rs:127:1: item name starts with its containing module's name
-rand-0.7.3/src/seq/index.rs:139:13: usage of wildcard import for enum variants
-rand-0.7.3/src/seq/index.rs:159:1: item name starts with its containing module's name
-rand-0.7.3/src/seq/index.rs:171:13: usage of wildcard import for enum variants
-rand-0.7.3/src/seq/index.rs:180:13: usage of wildcard import for enum variants
-rand-0.7.3/src/seq/index.rs:223:18: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-rand-0.7.3/src/seq/index.rs:224:18: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-rand-0.7.3/src/seq/index.rs:233:25: casting `u32` to `f32` causes a loss of precision (`u32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)
-rand-0.7.3/src/seq/index.rs:236:27: casting `u32` to `f32` causes a loss of precision (`u32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)
-rand-0.7.3/src/seq/index.rs:244:12: casting `u32` to `f32` causes a loss of precision (`u32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)
-rand-0.7.3/src/seq/index.rs:244:37: casting `u32` to `f32` causes a loss of precision (`u32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)
-rand-0.7.3/src/seq/index.rs:29:1: item name starts with its containing module's name
-rand-0.7.3/src/seq/index.rs:39:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/seq/index.rs:48:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/seq/index.rs:60:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/seq/index.rs:69:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/seq/index.rs:78:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/seq/index.rs:87:5: method `into_iter` can be confused for the standard trait method `std::iter::IntoIterator::into_iter`
-rand-0.7.3/src/seq/index.rs:87:5: this method could have a `#[must_use]` attribute
-rand-0.7.3/src/seq/index.rs:97:13: usage of wildcard import for enum variants
-rand-0.7.3/src/seq/mod.rs:141:5: docs for function returning `Result` missing `# Errors` section
-rand-0.7.3/src/seq/mod.rs:168:5: docs for function returning `Result` missing `# Errors` section
-rand-0.7.3/src/seq/mod.rs:229:4: needless `fn main` in doctest
-rand-0.7.3/src/seq/mod.rs:292:29: casting `usize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`usize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-rand-0.7.3/src/seq/mod.rs:410:23: calling `std::marker::PhantomData::default()` is more clear than this expression
-rand-0.7.3/src/seq/mod.rs:45:4: needless `fn main` in doctest
-rand-0.7.3/src/seq/mod.rs:527:26: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-rand_core-0.6.0/src/block.rs:117:1: item name starts with its containing module's name
-rand_core-0.6.0/src/block.rs:153:5: you have declared `#[inline(always)]` on `index`. This is usually a bad idea
-rand_core-0.6.0/src/block.rs:230:5: you have declared `#[inline(always)]` on `try_fill_bytes`. This is usually a bad idea
-rand_core-0.6.0/src/block.rs:240:5: you have declared `#[inline(always)]` on `from_seed`. This is usually a bad idea
-rand_core-0.6.0/src/block.rs:245:5: you have declared `#[inline(always)]` on `seed_from_u64`. This is usually a bad idea
-rand_core-0.6.0/src/block.rs:250:5: you have declared `#[inline(always)]` on `from_rng`. This is usually a bad idea
-rand_core-0.6.0/src/block.rs:280:1: item name starts with its containing module's name
-rand_core-0.6.0/src/block.rs:319:5: you have declared `#[inline(always)]` on `index`. This is usually a bad idea
-rand_core-0.6.0/src/block.rs:405:5: you have declared `#[inline(always)]` on `try_fill_bytes`. This is usually a bad idea
-rand_core-0.6.0/src/block.rs:415:5: you have declared `#[inline(always)]` on `from_seed`. This is usually a bad idea
-rand_core-0.6.0/src/block.rs:420:5: you have declared `#[inline(always)]` on `seed_from_u64`. This is usually a bad idea
-rand_core-0.6.0/src/block.rs:425:5: you have declared `#[inline(always)]` on `from_rng`. This is usually a bad idea
-rand_core-0.6.0/src/block.rs:67:14: you should put `module][crate::block` between ticks in the documentation
-rand_core-0.6.0/src/block.rs:68:1: item name starts with its containing module's name
-rand_core-0.6.0/src/error.rs:106:5: this method could have a `#[must_use]` attribute
-rand_core-0.6.0/src/error.rs:87:5: this method could have a `#[must_use]` attribute
-rand_core-0.6.0/src/error.rs:95:74: casting `u32` to `i32` may wrap around the value
-rand_core-0.6.0/src/lib.rs:179:5: docs for function returning `Result` missing `# Errors` section
-rand_core-0.6.0/src/lib.rs:301:5: this method could have a `#[must_use]` attribute
-rand_core-0.6.0/src/lib.rs:303:26: long literal lacking separators
-rand_core-0.6.0/src/lib.rs:304:26: long literal lacking separators
-rand_core-0.6.0/src/lib.rs:313:30: casting `u64` to `u32` may truncate the value
-rand_core-0.6.0/src/lib.rs:314:23: casting `u64` to `u32` may truncate the value
-rand_core-0.6.0/src/lib.rs:346:5: docs for function returning `Result` missing `# Errors` section
-rand_core-0.6.0/src/lib.rs:381:5: you have declared `#[inline(always)]` on `next_u32`. This is usually a bad idea
-rand_core-0.6.0/src/lib.rs:386:5: you have declared `#[inline(always)]` on `next_u64`. This is usually a bad idea
-rand_core-0.6.0/src/lib.rs:391:5: you have declared `#[inline(always)]` on `fill_bytes`. This is usually a bad idea
-rand_core-0.6.0/src/lib.rs:396:5: you have declared `#[inline(always)]` on `try_fill_bytes`. This is usually a bad idea
-rayon-1.5.0/src/collections/binary_heap.rs:7:5: usage of wildcard import
-rayon-1.5.0/src/collections/binary_heap.rs:8:5: usage of wildcard import
-rayon-1.5.0/src/collections/btree_map.rs:7:5: usage of wildcard import
-rayon-1.5.0/src/collections/btree_map.rs:8:5: usage of wildcard import
-rayon-1.5.0/src/collections/btree_set.rs:7:5: usage of wildcard import
-rayon-1.5.0/src/collections/btree_set.rs:8:5: usage of wildcard import
-rayon-1.5.0/src/collections/hash_map.rs:10:5: usage of wildcard import
-rayon-1.5.0/src/collections/hash_map.rs:9:5: usage of wildcard import
-rayon-1.5.0/src/collections/hash_set.rs:10:5: usage of wildcard import
-rayon-1.5.0/src/collections/hash_set.rs:9:5: usage of wildcard import
-rayon-1.5.0/src/collections/linked_list.rs:7:5: usage of wildcard import
-rayon-1.5.0/src/collections/linked_list.rs:8:5: usage of wildcard import
-rayon-1.5.0/src/collections/mod.rs:59:32: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
-rayon-1.5.0/src/collections/vec_deque.rs:8:5: usage of wildcard import
-rayon-1.5.0/src/collections/vec_deque.rs:9:5: usage of wildcard import
-rayon-1.5.0/src/compile_fail/cannot_collect_filtermap_data.rs:2:1: needless `fn main` in doctest
-rayon-1.5.0/src/compile_fail/cannot_zip_filtered_data.rs:2:1: needless `fn main` in doctest
-rayon-1.5.0/src/compile_fail/cell_par_iter.rs:2:1: needless `fn main` in doctest
-rayon-1.5.0/src/compile_fail/no_send_par_iter.rs:25:1: needless `fn main` in doctest
-rayon-1.5.0/src/compile_fail/no_send_par_iter.rs:46:1: needless `fn main` in doctest
-rayon-1.5.0/src/compile_fail/no_send_par_iter.rs:4:1: needless `fn main` in doctest
-rayon-1.5.0/src/compile_fail/rc_par_iter.rs:2:1: needless `fn main` in doctest
-rayon-1.5.0/src/iter/chain.rs:103:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/chain.rs:122:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/chain.rs:128:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/chain.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/chain.rs:221:36: you should put `ExactSizeIterator` between ticks in the documentation
-rayon-1.5.0/src/iter/chain.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/chain.rs:51:38: use Option::map_or_else instead of an if let/else
-rayon-1.5.0/src/iter/chain.rs:58:14: `a` is being shadowed
-rayon-1.5.0/src/iter/chain.rs:58:17: `b` is being shadowed
-rayon-1.5.0/src/iter/chain.rs:78:14: `a` is being shadowed
-rayon-1.5.0/src/iter/chain.rs:78:17: `b` is being shadowed
-rayon-1.5.0/src/iter/chain.rs:97:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/chunks.rs:3:5: usage of wildcard import
-rayon-1.5.0/src/iter/chunks.rs:4:5: usage of wildcard import
-rayon-1.5.0/src/iter/chunks.rs:77:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/chunks.rs:83:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/cloned.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/cloned.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/cloned.rs:71:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/cloned.rs:75:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/collect/consumer.rs:141:5: you should put `CollectReducer` between ticks in the documentation
-rayon-1.5.0/src/iter/collect/consumer.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/collect/consumer.rs:28:5: you should put `CollectResult` between ticks in the documentation
-rayon-1.5.0/src/iter/collect/consumer.rs:36:37: generally you want to avoid `&mut &mut _` if possible
-rayon-1.5.0/src/iter/collect/consumer.rs:36:37: generally you want to avoid `&mut &mut _` if possible
-rayon-1.5.0/src/iter/collect/mod.rs:154:9: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-rayon-1.5.0/src/iter/copied.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/copied.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/copied.rs:71:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/copied.rs:75:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/empty.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/empty.rs:24:1: this function could have a `#[must_use]` attribute
-rayon-1.5.0/src/iter/empty.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/enumerate.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/enumerate.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/enumerate.rs:64:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/enumerate.rs:68:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/extend.rs:143:63: I see you're using a LinkedList! Perhaps you meant some other data structure?
-rayon-1.5.0/src/iter/extend.rs:182:57: I see you're using a LinkedList! Perhaps you meant some other data structure?
-rayon-1.5.0/src/iter/extend.rs:218:32: I see you're using a LinkedList! Perhaps you meant some other data structure?
-rayon-1.5.0/src/iter/extend.rs:218:59: I see you're using a LinkedList! Perhaps you meant some other data structure?
-rayon-1.5.0/src/iter/extend.rs:25:42: I see you're using a LinkedList! Perhaps you meant some other data structure?
-rayon-1.5.0/src/iter/extend.rs:287:62: I see you're using a LinkedList! Perhaps you meant some other data structure?
-rayon-1.5.0/src/iter/extend.rs:322:56: I see you're using a LinkedList! Perhaps you meant some other data structure?
-rayon-1.5.0/src/iter/extend.rs:41:27: I see you're using a LinkedList! Perhaps you meant some other data structure?
-rayon-1.5.0/src/iter/extend.rs:47:30: I see you're using a LinkedList! Perhaps you meant some other data structure?
-rayon-1.5.0/src/iter/extend.rs:47:56: I see you're using a LinkedList! Perhaps you meant some other data structure?
-rayon-1.5.0/src/iter/extend.rs:47:74: I see you're using a LinkedList! Perhaps you meant some other data structure?
-rayon-1.5.0/src/iter/extend.rs:53:29: I see you're using a LinkedList! Perhaps you meant some other data structure?
-rayon-1.5.0/src/iter/extend.rs:57:36: I see you're using a LinkedList! Perhaps you meant some other data structure?
-rayon-1.5.0/src/iter/extend.rs:59:61: I see you're using a LinkedList! Perhaps you meant some other data structure?
-rayon-1.5.0/src/iter/filter.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/filter.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/filter_map.rs:123:9: use Option::map_or instead of an if let/else
-rayon-1.5.0/src/iter/filter_map.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/filter_map.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/find.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/find.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/find_first_last/mod.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/find_first_last/mod.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/find_first_last/mod.rs:32:67: you should put `MatchPosition` between ticks in the documentation
-rayon-1.5.0/src/iter/flat_map.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/flat_map.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/flat_map_iter.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/flat_map_iter.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/flatten.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/flatten.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/flatten_iter.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/flatten_iter.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/fold.rs:158:13: binding's name is too similar to existing binding
-rayon-1.5.0/src/iter/fold.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/fold.rs:204:1: item name starts with its containing module's name
-rayon-1.5.0/src/iter/fold.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/for_each.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/for_each.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/inspect.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/inspect.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/inspect.rs:83:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/inspect.rs:88:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/interleave.rs:111:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/interleave.rs:119:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/interleave.rs:195:30: you should put `self.i_len` between ticks in the documentation
-rayon-1.5.0/src/iter/interleave.rs:195:43: you should put `self.j_len` between ticks in the documentation
-rayon-1.5.0/src/iter/interleave.rs:199:23: you should put `self.i_len` between ticks in the documentation
-rayon-1.5.0/src/iter/interleave.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/interleave.rs:200:23: you should put `self.j_len` between ticks in the documentation
-rayon-1.5.0/src/iter/interleave.rs:249:41: you should put `DoubleEndedIterator` between ticks in the documentation
-rayon-1.5.0/src/iter/interleave.rs:250:5: you should put `ExactSizeIterator` between ticks in the documentation
-rayon-1.5.0/src/iter/interleave.rs:263:33: you should put `InterleaveSeq` between ticks in the documentation
-rayon-1.5.0/src/iter/interleave.rs:280:17: wildcard match will miss any future added variants
-rayon-1.5.0/src/iter/interleave.rs:285:17: wildcard match will miss any future added variants
-rayon-1.5.0/src/iter/interleave.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/interleave.rs:313:9: `if` chain can be rewritten with `match`
-rayon-1.5.0/src/iter/interleave.rs:82:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/interleave.rs:90:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/interleave_shortest.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/intersperse.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/intersperse.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/intersperse.rs:90:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/intersperse.rs:96:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/len.rs:12:1: item name ends with its containing module's name
-rayon-1.5.0/src/iter/len.rs:146:1: item name ends with its containing module's name
-rayon-1.5.0/src/iter/len.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/len.rs:200:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/len.rs:205:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/len.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/len.rs:66:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/len.rs:71:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/map.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/map.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/map.rs:84:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/map.rs:89:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/map_with.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/map_with.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/map_with.rs:419:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/map_with.rs:425:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/map_with.rs:90:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/map_with.rs:96:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/mod.rs:1874:24: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-rayon-1.5.0/src/iter/mod.rs:2171:1: trait `IndexedParallelIterator` has a `len` method but no (possibly inherited) `is_empty` method
-rayon-1.5.0/src/iter/mod.rs:2371:26: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-rayon-1.5.0/src/iter/mod.rs:2411:26: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-rayon-1.5.0/src/iter/mod.rs:82:5: usage of wildcard import
-rayon-1.5.0/src/iter/multizip.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/multizip.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/noop.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/once.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/once.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/panic_fuse.rs:102:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/panic_fuse.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/panic_fuse.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/panic_fuse.rs:98:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/par_bridge.rs:136:28: redundant else block
-rayon-1.5.0/src/iter/par_bridge.rs:163:28: redundant else block
-rayon-1.5.0/src/iter/plumbing/mod.rs:216:58: you should put `find_first` between ticks in the documentation
-rayon-1.5.0/src/iter/plumbing/mod.rs:359:5: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/plumbing/mod.rs:364:5: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/plumbing/mod.rs:399:5: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/plumbing/mod.rs:53:19: you should put `DoubleEndedIterator` between ticks in the documentation
-rayon-1.5.0/src/iter/plumbing/mod.rs:53:43: you should put `ExactSizeIterator` between ticks in the documentation
-rayon-1.5.0/src/iter/plumbing/mod.rs:54:31: you should put `IntoIterator` between ticks in the documentation
-rayon-1.5.0/src/iter/plumbing/mod.rs:55:5: you should put `IntoIterator` between ticks in the documentation
-rayon-1.5.0/src/iter/positions.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/positions.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/product.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/reduce.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/repeat.rs:103:1: item name starts with its containing module's name
-rayon-1.5.0/src/iter/repeat.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/repeat.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/rev.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/rev.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/rev.rs:63:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/rev.rs:68:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/skip.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/skip.rs:3:5: usage of wildcard import
-rayon-1.5.0/src/iter/skip.rs:68:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/skip.rs:73:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/splitter.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/splitter.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/step_by.rs:4:5: usage of wildcard import
-rayon-1.5.0/src/iter/step_by.rs:5:5: usage of wildcard import
-rayon-1.5.0/src/iter/step_by.rs:73:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/step_by.rs:79:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/sum.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/take.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/take.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/take.rs:67:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/take.rs:72:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/try_fold.rs:190:1: item name starts with its containing module's name
-rayon-1.5.0/src/iter/try_fold.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/try_fold.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/try_reduce.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/try_reduce_with.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/unzip.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/unzip.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/update.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/update.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/update.rs:82:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/update.rs:87:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/while_some.rs:130:22: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-rayon-1.5.0/src/iter/while_some.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/while_some.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/zip.rs:102:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/zip.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/zip.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/iter/zip.rs:74:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/zip.rs:79:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/zip.rs:97:9: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/iter/zip_eq.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/iter/zip_eq.rs:2:5: usage of wildcard import
-rayon-1.5.0/src/option.rs:8:5: usage of wildcard import
-rayon-1.5.0/src/option.rs:9:5: usage of wildcard import
-rayon-1.5.0/src/par_either.rs:1:5: usage of wildcard import
-rayon-1.5.0/src/par_either.rs:3:5: usage of wildcard import
-rayon-1.5.0/src/private.rs:9:1: item name starts with its containing module's name
-rayon-1.5.0/src/range.rs:19:5: usage of wildcard import
-rayon-1.5.0/src/range.rs:20:5: usage of wildcard import
-rayon-1.5.0/src/range_inclusive.rs:194:9: an inclusive range would be more readable
-rayon-1.5.0/src/range_inclusive.rs:194:9: an inclusive range would be more readable
-rayon-1.5.0/src/range_inclusive.rs:19:5: usage of wildcard import
-rayon-1.5.0/src/range_inclusive.rs:209:9: an inclusive range would be more readable
-rayon-1.5.0/src/range_inclusive.rs:209:9: an inclusive range would be more readable
-rayon-1.5.0/src/range_inclusive.rs:20:5: usage of wildcard import
-rayon-1.5.0/src/range_inclusive.rs:231:9: an inclusive range would be more readable
-rayon-1.5.0/src/range_inclusive.rs:231:9: an inclusive range would be more readable
-rayon-1.5.0/src/result.rs:8:5: usage of wildcard import
-rayon-1.5.0/src/result.rs:9:5: usage of wildcard import
-rayon-1.5.0/src/slice/mergesort.rs:102:5: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/slice/mergesort.rs:109:5: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/slice/mergesort.rs:114:5: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/slice/mergesort.rs:211:5: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/slice/mergesort.rs:217:5: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/slice/mergesort.rs:251:5: you should put `TimSort` between ticks in the documentation
-rayon-1.5.0/src/slice/mergesort.rs:252:5: you should put bare URLs between `<`/`>` or make a proper Markdown link
-rayon-1.5.0/src/slice/mergesort.rs:286:59: you should put `TimSort` between ticks in the documentation
-rayon-1.5.0/src/slice/mergesort.rs:333:24: redundant else block
-rayon-1.5.0/src/slice/mergesort.rs:513:5: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/slice/mergesort.rs:521:5: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/slice/mergesort.rs:7:5: usage of wildcard import
-rayon-1.5.0/src/slice/mergesort.rs:98:5: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/slice/mod.rs:15:5: usage of wildcard import
-rayon-1.5.0/src/slice/mod.rs:16:5: usage of wildcard import
-rayon-1.5.0/src/slice/mod.rs:17:5: usage of wildcard import
-rayon-1.5.0/src/slice/mod.rs:25:1: item name ends with its containing module's name
-rayon-1.5.0/src/slice/mod.rs:657:5: this method could have a `#[must_use]` attribute
-rayon-1.5.0/src/slice/mod.rs:971:5: this method could have a `#[must_use]` attribute
-rayon-1.5.0/src/slice/quicksort.rs:230:36: you should put `BlockQuicksort` between ticks in the documentation
-rayon-1.5.0/src/slice/quicksort.rs:233:1: this function has too many lines (117/100)
-rayon-1.5.0/src/slice/quicksort.rs:258:26: integer type suffix should be separated by an underscore
-rayon-1.5.0/src/slice/quicksort.rs:265:26: integer type suffix should be separated by an underscore
-rayon-1.5.0/src/slice/quicksort.rs:268:5: adding items after statements is confusing, since items exist from the start of the scope
-rayon-1.5.0/src/slice/quicksort.rs:308:30: casting `usize` to `u8` may truncate the value
-rayon-1.5.0/src/slice/quicksort.rs:325:30: casting `usize` to `u8` may truncate the value
-rayon-1.5.0/src/slice/quicksort.rs:393:36: casting `u8` to `isize` may wrap around the value on targets with 32-bit wide pointers
-rayon-1.5.0/src/slice/quicksort.rs:405:40: casting `u8` to `isize` may wrap around the value on targets with 32-bit wide pointers
-rayon-1.5.0/src/slice/quicksort.rs:430:14: `pivot` is being shadowed
-rayon-1.5.0/src/slice/quicksort.rs:439:13: `pivot` is being shadowed
-rayon-1.5.0/src/slice/quicksort.rs:482:10: `pivot` is being shadowed
-rayon-1.5.0/src/slice/quicksort.rs:491:9: `pivot` is being shadowed
-rayon-1.5.0/src/slice/quicksort.rs:534:26: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-rayon-1.5.0/src/slice/quicksort.rs:545:17: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
-rayon-1.5.0/src/slice/quicksort.rs:588:17: the operation is ineffective. Consider reducing it to `len / 4`
-rayon-1.5.0/src/slice/quicksort.rs:716:14: `pivot` is being shadowed
-rayon-1.5.0/src/split_producer.rs:56:16: use Option::map_or_else instead of an if let/else
-rayon-1.5.0/src/split_producer.rs:92:9: use Option::map_or instead of an if let/else
-rayon-1.5.0/src/str.rs:16:5: usage of wildcard import
-rayon-1.5.0/src/str.rs:17:5: usage of wildcard import
-rayon-1.5.0/src/str.rs:18:5: usage of wildcard import
-rayon-1.5.0/src/str.rs:25:5: casting `u8` to `i8` may wrap around the value
-rayon-1.5.0/src/str.rs:715:9: stripping a suffix manually
-rayon-1.5.0/src/string.rs:5:5: usage of wildcard import
-rayon-1.5.0/src/vec.rs:137:12: length comparison to zero
-rayon-1.5.0/src/vec.rs:8:5: usage of wildcard import
-rayon-1.5.0/src/vec.rs:9:5: usage of wildcard import
-regex-1.3.2/src/backtrack.rs:100:13: redundant field names in struct initialization
-regex-1.3.2/src/backtrack.rs:133:17: it looks like the same item is being pushed into this Vec
-regex-1.3.2/src/backtrack.rs:145:20: unnecessary boolean `not` operation
-regex-1.3.2/src/backtrack.rs:199:13: usage of wildcard import for enum variants
-regex-1.3.2/src/backtrack.rs:223:29: redundant field names in struct initialization
-regex-1.3.2/src/backtrack.rs:230:66: redundant field names in struct initialization
-regex-1.3.2/src/backtrack.rs:284:21: casting `u32` to `u64` may become silently lossy if you later change the type
-regex-1.3.2/src/backtrack.rs:287:5: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-regex-1.3.2/src/backtrack.rs:97:13: redundant field names in struct initialization
-regex-1.3.2/src/backtrack.rs:98:13: redundant field names in struct initialization
-regex-1.3.2/src/backtrack.rs:99:13: redundant field names in struct initialization
-regex-1.3.2/src/compile.rs:1005:32: long literal lacking separators
-regex-1.3.2/src/compile.rs:1006:21: long literal lacking separators
-regex-1.3.2/src/compile.rs:1008:18: casting `u8` to `u64` may become silently lossy if you later change the type
-regex-1.3.2/src/compile.rs:1009:18: casting `u8` to `u64` may become silently lossy if you later change the type
-regex-1.3.2/src/compile.rs:1010:9: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
-regex-1.3.2/src/compile.rs:102:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/compile.rs:1037:37: casting `u16` to `u8` may truncate the value
-regex-1.3.2/src/compile.rs:1037:55: casting `u16` to `u8` may truncate the value
-regex-1.3.2/src/compile.rs:1040:28: casting `u16` to `u8` may truncate the value
-regex-1.3.2/src/compile.rs:1040:38: casting `u16` to `u8` may truncate the value
-regex-1.3.2/src/compile.rs:1051:25: integer type suffix should be separated by an underscore
-regex-1.3.2/src/compile.rs:1071:8: casting `u32` to `u64` may become silently lossy if you later change the type
-regex-1.3.2/src/compile.rs:112:5: docs for function returning `Result` missing `# Errors` section
-regex-1.3.2/src/compile.rs:154:30: redundant closure found
-regex-1.3.2/src/compile.rs:156:30: redundant closure found
-regex-1.3.2/src/compile.rs:185:5: this function's return value is unnecessarily wrapped by `Result`
-regex-1.3.2/src/compile.rs:187:40: redundant closure found
-regex-1.3.2/src/compile.rs:201:53: you should put `MaybeInsts` between ticks in the documentation
-regex-1.3.2/src/compile.rs:241:63: you should put `c_concat` between ticks in the documentation
-regex-1.3.2/src/compile.rs:245:5: this function has too many lines (111/100)
-regex-1.3.2/src/compile.rs:247:13: usage of wildcard import for enum variants
-regex-1.3.2/src/compile.rs:373:24: redundant field names in struct initialization
-regex-1.3.2/src/compile.rs:373:36: redundant field names in struct initialization
-regex-1.3.2/src/compile.rs:378:12: unnecessary boolean `not` operation
-regex-1.3.2/src/compile.rs:400:37: redundant field names in struct initialization
-regex-1.3.2/src/compile.rs:407:51: redundant field names in struct initialization
-regex-1.3.2/src/compile.rs:409:24: redundant field names in struct initialization
-regex-1.3.2/src/compile.rs:417:5: this function's return value is unnecessarily wrapped by `Result`
-regex-1.3.2/src/compile.rs:42:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/compile.rs:42:5: you should consider adding a `Default` implementation for `compile::Compiler`
-regex-1.3.2/src/compile.rs:444:5: this function's return value is unnecessarily wrapped by `Result`
-regex-1.3.2/src/compile.rs:445:57: redundant field names in struct initialization
-regex-1.3.2/src/compile.rs:446:20: redundant field names in struct initialization
-regex-1.3.2/src/compile.rs:466:20: redundant field names in struct initialization
-regex-1.3.2/src/compile.rs:466:32: redundant field names in struct initialization
-regex-1.3.2/src/compile.rs:519:13: usage of wildcard import for enum variants
-regex-1.3.2/src/compile.rs:55:57: you should put `size_limit` between ticks in the documentation
-regex-1.3.2/src/compile.rs:58:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/compile.rs:748:41: redundant field names in struct initialization
-regex-1.3.2/src/compile.rs:74:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/compile.rs:751:54: redundant field names in struct initialization
-regex-1.3.2/src/compile.rs:765:41: redundant field names in struct initialization
-regex-1.3.2/src/compile.rs:765:55: redundant field names in struct initialization
-regex-1.3.2/src/compile.rs:825:39: redundant field names in struct initialization
-regex-1.3.2/src/compile.rs:825:51: redundant field names in struct initialization
-regex-1.3.2/src/compile.rs:828:49: redundant field names in struct initialization
-regex-1.3.2/src/compile.rs:828:61: redundant field names in struct initialization
-regex-1.3.2/src/compile.rs:830:59: redundant field names in struct initialization
-regex-1.3.2/src/compile.rs:830:71: redundant field names in struct initialization
-regex-1.3.2/src/compile.rs:832:43: redundant field names in struct initialization
-regex-1.3.2/src/compile.rs:835:41: redundant field names in struct initialization
-regex-1.3.2/src/compile.rs:835:53: redundant field names in struct initialization
-regex-1.3.2/src/compile.rs:835:67: redundant field names in struct initialization
-regex-1.3.2/src/compile.rs:83:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/compile.rs:896:5: this function's return value is unnecessarily wrapped by `Result`
-regex-1.3.2/src/compile.rs:905:17: redundant field names in struct initialization
-regex-1.3.2/src/compile.rs:953:17: you should put `HashMap` between ticks in the documentation
-regex-1.3.2/src/compile.rs:95:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/compile.rs:980:26: integer type suffix should be separated by an underscore
-regex-1.3.2/src/compile.rs:994:44: redundant field names in struct initialization
-regex-1.3.2/src/compile.rs:994:54: redundant field names in struct initialization
-regex-1.3.2/src/dfa.rs:1007:17: binding's name is too similar to existing binding
-regex-1.3.2/src/dfa.rs:1010:22: binding's name is too similar to existing binding
-regex-1.3.2/src/dfa.rs:1059:13: usage of wildcard import for enum variants
-regex-1.3.2/src/dfa.rs:1060:13: usage of wildcard import for enum variants
-regex-1.3.2/src/dfa.rs:1084:38: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-regex-1.3.2/src/dfa.rs:1087:38: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-regex-1.3.2/src/dfa.rs:1090:38: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-regex-1.3.2/src/dfa.rs:1093:38: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-regex-1.3.2/src/dfa.rs:1096:38: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-regex-1.3.2/src/dfa.rs:1101:38: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-regex-1.3.2/src/dfa.rs:1104:38: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-regex-1.3.2/src/dfa.rs:1107:38: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-regex-1.3.2/src/dfa.rs:1117:30: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-regex-1.3.2/src/dfa.rs:1120:47: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-regex-1.3.2/src/dfa.rs:1121:30: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-regex-1.3.2/src/dfa.rs:1129:13: you should put `is_match` between ticks in the documentation
-regex-1.3.2/src/dfa.rs:1134:13: you should put `is_match` between ticks in the documentation
-regex-1.3.2/src/dfa.rs:1185:68: you should put `is_match` between ticks in the documentation
-regex-1.3.2/src/dfa.rs:1193:13: usage of wildcard import for enum variants
-regex-1.3.2/src/dfa.rs:1244:50: you should put `current_state` between ticks in the documentation
-regex-1.3.2/src/dfa.rs:1338:58: you should put `STATE_DEAD` between ticks in the documentation
-regex-1.3.2/src/dfa.rs:1339:9: you should put `STATE_UNKNOWN` between ticks in the documentation
-regex-1.3.2/src/dfa.rs:1366:25: you should put `STATE_DEAD` between ticks in the documentation
-regex-1.3.2/src/dfa.rs:1366:46: you should put `STATE_UNKNOWN` between ticks in the documentation
-regex-1.3.2/src/dfa.rs:1367:41: you have declared `#[inline(always)]` on `start_state`. This is usually a bad idea
-regex-1.3.2/src/dfa.rs:1380:14: the operation is ineffective. Consider reducing it to `(empty_flags.start as u8)`
-regex-1.3.2/src/dfa.rs:1388:15: indexing into a vector may panic
-regex-1.3.2/src/dfa.rs:1412:20: unused `self` argument
-regex-1.3.2/src/dfa.rs:1438:9: unused `self` argument
-regex-1.3.2/src/dfa.rs:1472:9: you should put `StatePtr` between ticks in the documentation
-regex-1.3.2/src/dfa.rs:1490:54: casting `i32` to `u8` may lose the sign of the value
-regex-1.3.2/src/dfa.rs:1490:54: casting `i32` to `u8` may truncate the value
-regex-1.3.2/src/dfa.rs:1521:20: you should put `num_byte_classes` between ticks in the documentation
-regex-1.3.2/src/dfa.rs:1529:41: you have declared `#[inline(always)]` on `byte_class`. This is usually a bad idea
-regex-1.3.2/src/dfa.rs:1537:14: you should put `byte_class` between ticks in the documentation
-regex-1.3.2/src/dfa.rs:1538:41: you have declared `#[inline(always)]` on `u8_class`. This is usually a bad idea
-regex-1.3.2/src/dfa.rs:1562:18: you should put `STATE_START` between ticks in the documentation
-regex-1.3.2/src/dfa.rs:1614:13: redundant field names in struct initialization
-regex-1.3.2/src/dfa.rs:1651:38: redundant field names in struct initialization
-regex-1.3.2/src/dfa.rs:1700:17: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-regex-1.3.2/src/dfa.rs:1701:18: digits of hex or binary literal not grouped by four
-regex-1.3.2/src/dfa.rs:1705:19: digits of hex or binary literal not grouped by four
-regex-1.3.2/src/dfa.rs:1708:16: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-regex-1.3.2/src/dfa.rs:1709:18: digits of hex or binary literal not grouped by four
-regex-1.3.2/src/dfa.rs:1713:19: digits of hex or binary literal not grouped by four
-regex-1.3.2/src/dfa.rs:1716:18: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-regex-1.3.2/src/dfa.rs:1717:18: digits of hex or binary literal not grouped by four
-regex-1.3.2/src/dfa.rs:1721:19: digits of hex or binary literal not grouped by four
-regex-1.3.2/src/dfa.rs:1727:14: casting `u8` to `u16` may become silently lossy if you later change the type
-regex-1.3.2/src/dfa.rs:1732:15: this argument (2 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-regex-1.3.2/src/dfa.rs:1736:22: this argument (2 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-regex-1.3.2/src/dfa.rs:1741:9: match expression looks like `matches!` macro
-regex-1.3.2/src/dfa.rs:1747:16: this argument (2 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-regex-1.3.2/src/dfa.rs:1751:18: casting `u16` to `u8` may truncate the value
-regex-1.3.2/src/dfa.rs:1815:38: casting `usize` to `u8` may truncate the value
-regex-1.3.2/src/dfa.rs:1821:21: casting `u32` to `u64` may become silently lossy if you later change the type
-regex-1.3.2/src/dfa.rs:1824:5: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-regex-1.3.2/src/dfa.rs:1848:5: you should put bare URLs between `<`/`>` or make a proper Markdown link
-regex-1.3.2/src/dfa.rs:1850:18: casting `i32` to `u32` may lose the sign of the value
-regex-1.3.2/src/dfa.rs:1857:5: you should put bare URLs between `<`/`>` or make a proper Markdown link
-regex-1.3.2/src/dfa.rs:1860:17: casting `u32` to `i32` may wrap around the value
-regex-1.3.2/src/dfa.rs:1867:5: you should put bare URLs between `<`/`>` or make a proper Markdown link
-regex-1.3.2/src/dfa.rs:1870:19: casting `u32` to `u8` may truncate the value
-regex-1.3.2/src/dfa.rs:1873:15: casting `u32` to `u8` may truncate the value
-regex-1.3.2/src/dfa.rs:1876:5: you should put bare URLs between `<`/`>` or make a proper Markdown link
-regex-1.3.2/src/dfa.rs:1882:26: casting `u8` to `u32` may become silently lossy if you later change the type
-regex-1.3.2/src/dfa.rs:1884:15: casting `u8` to `u32` may become silently lossy if you later change the type
-regex-1.3.2/src/dfa.rs:277:17: casting `u32` to `i32` may wrap around the value
-regex-1.3.2/src/dfa.rs:277:31: casting `u32` to `i32` may wrap around the value
-regex-1.3.2/src/dfa.rs:295:20: casting `usize` to `i32` may truncate the value on targets with 64-bit wide pointers
-regex-1.3.2/src/dfa.rs:295:20: casting `usize` to `i32` may wrap around the value on targets with 32-bit wide pointers
-regex-1.3.2/src/dfa.rs:299:21: casting `i32` to `usize` may lose the sign of the value
-regex-1.3.2/src/dfa.rs:34:46: you should put bare URLs between `<`/`>` or make a proper Markdown link
-regex-1.3.2/src/dfa.rs:398:1: more than 3 bools in a struct
-regex-1.3.2/src/dfa.rs:446:41: you have declared `#[inline(always)]` on `forward`. This is usually a bad idea
-regex-1.3.2/src/dfa.rs:457:13: redundant field names in struct initialization
-regex-1.3.2/src/dfa.rs:459:13: redundant field names in struct initialization
-regex-1.3.2/src/dfa.rs:460:13: redundant field names in struct initialization
-regex-1.3.2/src/dfa.rs:476:41: you have declared `#[inline(always)]` on `reverse`. This is usually a bad idea
-regex-1.3.2/src/dfa.rs:487:13: redundant field names in struct initialization
-regex-1.3.2/src/dfa.rs:489:13: redundant field names in struct initialization
-regex-1.3.2/src/dfa.rs:490:13: redundant field names in struct initialization
-regex-1.3.2/src/dfa.rs:506:41: you have declared `#[inline(always)]` on `forward_many`. This is usually a bad idea
-regex-1.3.2/src/dfa.rs:518:13: redundant field names in struct initialization
-regex-1.3.2/src/dfa.rs:520:13: redundant field names in struct initialization
-regex-1.3.2/src/dfa.rs:554:41: you have declared `#[inline(always)]` on `exec_at`. This is usually a bad idea
-regex-1.3.2/src/dfa.rs:555:5: this function has too many lines (101/100)
-regex-1.3.2/src/dfa.rs:58:9: usage of wildcard import for enum variants
-regex-1.3.2/src/dfa.rs:667:21: binding's name is too similar to existing binding
-regex-1.3.2/src/dfa.rs:747:41: you have declared `#[inline(always)]` on `exec_at_reverse`. This is usually a bad idea
-regex-1.3.2/src/dfa.rs:795:21: binding's name is too similar to existing binding
-regex-1.3.2/src/dfa.rs:848:9: you should put `next_si` between ticks in the documentation
-regex-1.3.2/src/dfa.rs:852:41: you have declared `#[inline(always)]` on `next_si`. This is usually a bad idea
-regex-1.3.2/src/dfa.rs:885:12: you should put `STATE_DEAD` between ticks in the documentation
-regex-1.3.2/src/dfa.rs:889:9: you should put `STATE_UNKNOWN` between ticks in the documentation
-regex-1.3.2/src/dfa.rs:897:13: usage of wildcard import for enum variants
-regex-1.3.2/src/dfa.rs:979:29: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-regex-1.3.2/src/error.rs:6:1: this seems like a manual implementation of the non-exhaustive pattern
-regex-1.3.2/src/exec.rs:1000:14: you should put `captures_nfa` between ticks in the documentation
-regex-1.3.2/src/exec.rs:100:1: item name starts with its containing module's name
-regex-1.3.2/src/exec.rs:1028:5: this function has too many arguments (9/7)
-regex-1.3.2/src/exec.rs:1039:13: usage of wildcard import for enum variants
-regex-1.3.2/src/exec.rs:1144:13: usage of wildcard import for enum variants
-regex-1.3.2/src/exec.rs:1179:26: this `match` has identical arm bodies
-regex-1.3.2/src/exec.rs:122:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/exec.rs:1250:41: you have declared `#[inline(always)]` on `searcher`. This is usually a bad idea
-regex-1.3.2/src/exec.rs:1260:41: you have declared `#[inline(always)]` on `searcher_str`. This is usually a bad idea
-regex-1.3.2/src/exec.rs:1270:17: you should put `RegexSet` between ticks in the documentation
-regex-1.3.2/src/exec.rs:1280:17: you should put `RegexSet` between ticks in the documentation
-regex-1.3.2/src/exec.rs:137:9: field assignment outside of initializer for an instance created with Default::default()
-regex-1.3.2/src/exec.rs:142:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/exec.rs:158:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/exec.rs:168:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/exec.rs:181:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/exec.rs:195:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/exec.rs:204:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/exec.rs:210:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/exec.rs:245:62: this `if` has identical blocks
-regex-1.3.2/src/exec.rs:251:21: unnecessary boolean `not` operation
-regex-1.3.2/src/exec.rs:262:60: this `if` has identical blocks
-regex-1.3.2/src/exec.rs:268:21: unnecessary boolean `not` operation
-regex-1.3.2/src/exec.rs:278:13: redundant field names in struct initialization
-regex-1.3.2/src/exec.rs:281:13: redundant field names in struct initialization
-regex-1.3.2/src/exec.rs:286:5: docs for function returning `Result` missing `# Errors` section
-regex-1.3.2/src/exec.rs:300:30: redundant field names in struct initialization
-regex-1.3.2/src/exec.rs:308:17: binding's name is too similar to existing binding
-regex-1.3.2/src/exec.rs:329:13: redundant field names in struct initialization
-regex-1.3.2/src/exec.rs:330:13: redundant field names in struct initialization
-regex-1.3.2/src/exec.rs:331:13: redundant field names in struct initialization
-regex-1.3.2/src/exec.rs:334:13: redundant field names in struct initialization
-regex-1.3.2/src/exec.rs:340:19: redundant field names in struct initialization
-regex-1.3.2/src/exec.rs:344:27: unused `self` argument
-regex-1.3.2/src/exec.rs:383:41: you have declared `#[inline(always)]` on `shortest_match_at`. This is usually a bad idea
-regex-1.3.2/src/exec.rs:388:41: you have declared `#[inline(always)]` on `is_match_at`. This is usually a bad idea
-regex-1.3.2/src/exec.rs:393:41: you have declared `#[inline(always)]` on `find_at`. This is usually a bad idea
-regex-1.3.2/src/exec.rs:398:41: you have declared `#[inline(always)]` on `captures_read_at`. This is usually a bad idea
-regex-1.3.2/src/exec.rs:425:41: you have declared `#[inline(always)]` on `shortest_match_at`. This is usually a bad idea
-regex-1.3.2/src/exec.rs:44:1: item name starts with its containing module's name
-regex-1.3.2/src/exec.rs:473:9: you should put `shortest_match(...).is_some` between ticks in the documentation
-regex-1.3.2/src/exec.rs:474:41: you have declared `#[inline(always)]` on `is_match_at`. This is usually a bad idea
-regex-1.3.2/src/exec.rs:524:41: you have declared `#[inline(always)]` on `find_at`. This is usually a bad idea
-regex-1.3.2/src/exec.rs:52:1: item name starts with its containing module's name
-regex-1.3.2/src/exec.rs:686:13: usage of wildcard import for enum variants
-regex-1.3.2/src/exec.rs:727:13: usage of wildcard import for enum variants
-regex-1.3.2/src/exec.rs:767:13: usage of wildcard import for enum variants
-regex-1.3.2/src/exec.rs:783:41: you have declared `#[inline(always)]` on `shortest_dfa`. This is usually a bad idea
-regex-1.3.2/src/exec.rs:791:41: you have declared `#[inline(always)]` on `shortest_dfa_reverse_suffix`. This is usually a bad idea
-regex-1.3.2/src/exec.rs:823:13: usage of wildcard import for enum variants
-regex-1.3.2/src/exec.rs:868:13: usage of wildcard import for enum variants
-regex-1.3.2/src/exec.rs:897:31: you should put `shortest_nfa(...).is_some` between ticks in the documentation
-regex-1.3.2/src/exec.rs:899:9: you should put `shortest_nfa` between ticks in the documentation
-regex-1.3.2/src/exec.rs:905:14: you should put `match_nfa` between ticks in the documentation
-regex-1.3.2/src/exec.rs:930:14: you should put `shortest_nfa` between ticks in the documentation
-regex-1.3.2/src/exec.rs:981:14: you should put `find_nfa` between ticks in the documentation
-regex-1.3.2/src/expand.rs:170:27: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-regex-1.3.2/src/expand.rs:171:5: match expression looks like `matches!` macro
-regex-1.3.2/src/expand.rs:22:13: calling `push_str()` using a single-character string literal
-regex-1.3.2/src/expand.rs:27:23: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-regex-1.3.2/src/expand.rs:30:17: calling `push_str()` using a single-character string literal
-regex-1.3.2/src/expand.rs:38:30: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
-regex-1.3.2/src/expand.rs:42:21: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
-regex-1.3.2/src/expand.rs:50:1: item name starts with its containing module's name
-regex-1.3.2/src/expand.rs:69:23: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-regex-1.3.2/src/expand.rs:80:28: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
-regex-1.3.2/src/expand.rs:84:21: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
-regex-1.3.2/src/expand.rs:8:1: item name starts with its containing module's name
-regex-1.3.2/src/input.rs:142:1: item name ends with its containing module's name
-regex-1.3.2/src/input.rs:146:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/input.rs:15:1: item name starts with its containing module's name
-regex-1.3.2/src/input.rs:165:31: redundant field names in struct initialization
-regex-1.3.2/src/input.rs:178:13: usage of wildcard import for enum variants
-regex-1.3.2/src/input.rs:228:1: item name ends with its containing module's name
-regex-1.3.2/src/input.rs:236:21: redundant field names in struct initialization
-regex-1.3.2/src/input.rs:236:33: redundant field names in struct initialization
-regex-1.3.2/src/input.rs:24:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/input.rs:271:13: usage of wildcard import for enum variants
-regex-1.3.2/src/input.rs:29:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/input.rs:362:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/input.rs:370:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/input.rs:371:42: redundant closure found
-regex-1.3.2/src/input.rs:37:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/input.rs:388:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/input.rs:42:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/input.rs:47:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/input.rs:53:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/input.rs:58:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/input.rs:63:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/literal/imp.rs:101:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/literal/imp.rs:114:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/literal/imp.rs:127:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/literal/imp.rs:139:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/literal/imp.rs:144:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/literal/imp.rs:149:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/literal/imp.rs:154:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/literal/imp.rs:155:13: usage of wildcard import for enum variants
-regex-1.3.2/src/literal/imp.rs:160:30: this `match` has identical arm bodies
-regex-1.3.2/src/literal/imp.rs:167:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/literal/imp.rs:168:13: usage of wildcard import for enum variants
-regex-1.3.2/src/literal/imp.rs:211:20: redundant else block
-regex-1.3.2/src/literal/imp.rs:276:50: this `match` has identical arm bodies
-regex-1.3.2/src/literal/imp.rs:342:41: you have declared `#[inline(always)]` on `find`. This is usually a bad idea
-regex-1.3.2/src/literal/imp.rs:435:13: redundant field names in struct initialization
-regex-1.3.2/src/literal/imp.rs:436:13: redundant field names in struct initialization
-regex-1.3.2/src/literal/imp.rs:437:13: redundant field names in struct initialization
-regex-1.3.2/src/literal/imp.rs:438:13: redundant field names in struct initialization
-regex-1.3.2/src/literal/imp.rs:439:13: redundant field names in struct initialization
-regex-1.3.2/src/literal/imp.rs:440:13: redundant field names in struct initialization
-regex-1.3.2/src/literal/imp.rs:455:41: you have declared `#[inline(always)]` on `find`. This is usually a bad idea
-regex-1.3.2/src/literal/imp.rs:46:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/literal/imp.rs:481:41: you have declared `#[inline(always)]` on `is_suffix`. This is usually a bad idea
-regex-1.3.2/src/literal/imp.rs:51:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/literal/imp.rs:579:13: redundant field names in struct initialization
-regex-1.3.2/src/literal/imp.rs:57:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/literal/imp.rs:580:13: redundant field names in struct initialization
-regex-1.3.2/src/literal/imp.rs:583:13: redundant field names in struct initialization
-regex-1.3.2/src/literal/imp.rs:602:9: adding items after statements is confusing, since items exist from the start of the scope
-regex-1.3.2/src/literal/imp.rs:622:24: redundant else block
-regex-1.3.2/src/literal/imp.rs:62:18: this argument is passed by value, but not consumed in the function body
-regex-1.3.2/src/literal/imp.rs:637:24: redundant else block
-regex-1.3.2/src/literal/imp.rs:648:9: unneeded `return` statement
-regex-1.3.2/src/literal/imp.rs:651:44: you should put `BoyerMooreSearch` between ticks in the documentation
-regex-1.3.2/src/literal/imp.rs:65:13: redundant field names in struct initialization
-regex-1.3.2/src/literal/imp.rs:68:13: redundant field names in struct initialization
-regex-1.3.2/src/literal/imp.rs:783:32: redundant else block
-regex-1.3.2/src/literal/imp.rs:786:42: manual saturating arithmetic
-regex-1.3.2/src/literal/imp.rs:78:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/literal/imp.rs:84:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/literal/imp.rs:850:20: long literal lacking separators
-regex-1.3.2/src/literal/imp.rs:85:13: usage of wildcard import for enum variants
-regex-1.3.2/src/pikevm.rs:103:15: redundant field names in struct initialization
-regex-1.3.2/src/pikevm.rs:103:52: redundant field names in struct initialization
-regex-1.3.2/src/pikevm.rs:114:5: this function has too many arguments (8/7)
-regex-1.3.2/src/pikevm.rs:117:13: binding's name is too similar to existing binding
-regex-1.3.2/src/pikevm.rs:124:17: binding's name is too similar to existing binding
-regex-1.3.2/src/pikevm.rs:220:9: you should put `thread_caps` between ticks in the documentation
-regex-1.3.2/src/pikevm.rs:222:16: you should put `at_next` between ticks in the documentation
-regex-1.3.2/src/pikevm.rs:223:9: you should put `at_next` between ticks in the documentation
-regex-1.3.2/src/pikevm.rs:224:5: this function has too many arguments (8/7)
-regex-1.3.2/src/pikevm.rs:234:13: usage of wildcard import for enum variants
-regex-1.3.2/src/pikevm.rs:303:13: usage of wildcard import for enum variants
-regex-1.3.2/src/pikevm.rs:331:29: this expression mutably borrows a mutable reference. Consider reborrowing
-regex-1.3.2/src/pikevm.rs:88:5: this function has too many arguments (8/7)
-regex-1.3.2/src/prog.rs:102:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/prog.rs:113:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/prog.rs:120:9: match expression looks like `matches!` macro
-regex-1.3.2/src/prog.rs:128:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/prog.rs:134:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/prog.rs:141:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/prog.rs:147:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/prog.rs:164:41: you have declared `#[inline(always)]` on `deref`. This is usually a bad idea
-regex-1.3.2/src/prog.rs:172:13: usage of wildcard import for enum variants
-regex-1.3.2/src/prog.rs:18:1: more than 3 bools in a struct
-regex-1.3.2/src/prog.rs:236:13: using `write!()` with a format string that ends in a single newline
-regex-1.3.2/src/prog.rs:300:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/prog.rs:301:9: match expression looks like `matches!` macro
-regex-1.3.2/src/prog.rs:382:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/prog.rs:409:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/prog.rs:80:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/prog.rs:80:5: you should consider adding a `Default` implementation for `prog::Program`
-regex-1.3.2/src/re_builder.rs:267:17: docs for function returning `Result` missing `# Errors` section
-regex-1.3.2/src/re_builder.rs:267:17: docs for function returning `Result` missing `# Errors` section
-regex-1.3.2/src/re_builder.rs:4:1: more than 3 bools in a struct
-regex-1.3.2/src/re_builder.rs:57:17: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/re_builder.rs:57:17: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/re_builder.rs:68:17: docs for function returning `Result` missing `# Errors` section
-regex-1.3.2/src/re_builder.rs:68:17: docs for function returning `Result` missing `# Errors` section
-regex-1.3.2/src/re_bytes.rs:1017:9: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
-regex-1.3.2/src/re_bytes.rs:1039:9: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
-regex-1.3.2/src/re_bytes.rs:1093:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-regex-1.3.2/src/re_bytes.rs:1118:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-regex-1.3.2/src/re_bytes.rs:1133:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-regex-1.3.2/src/re_bytes.rs:118:5: docs for function returning `Result` missing `# Errors` section
-regex-1.3.2/src/re_bytes.rs:256:13: redundant field names in struct initialization
-regex-1.3.2/src/re_bytes.rs:29:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/re_bytes.rs:35:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/re_bytes.rs:42:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/re_bytes.rs:48:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/re_bytes.rs:558:29: you should put `shortest_match` between ticks in the documentation
-regex-1.3.2/src/re_bytes.rs:55:33: redundant field names in struct initialization
-regex-1.3.2/src/re_bytes.rs:55:47: redundant field names in struct initialization
-regex-1.3.2/src/re_bytes.rs:572:29: you should put `is_match` between ticks in the documentation
-regex-1.3.2/src/re_bytes.rs:720:13: redundant field names in struct initialization
-regex-1.3.2/src/re_bytes.rs:817:5: you should put `CaptureLocations` between ticks in the documentation
-regex-1.3.2/src/re_bytes.rs:843:1: item `re_bytes::CaptureLocations` has a public `len` method but no corresponding `is_empty` method
-regex-1.3.2/src/re_bytes.rs:849:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/re_bytes.rs:858:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/re_bytes.rs:869:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/re_bytes.rs:891:1: item `re_bytes::Captures<'t>` has a public `len` method but no corresponding `is_empty` method
-regex-1.3.2/src/re_bytes.rs:911:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/re_bytes.rs:917:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/re_bytes.rs:926:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/re_bytes.rs:955:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/re_set.rs:179:13: redundant field names in struct initialization
-regex-1.3.2/src/re_set.rs:179:13: redundant field names in struct initialization
-regex-1.3.2/src/re_set.rs:251:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/re_set.rs:251:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/re_set.rs:263:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/re_set.rs:263:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/re_set.rs:268:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/re_set.rs:268:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/re_set.rs:277:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/re_set.rs:277:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/re_set.rs:94:5: docs for function returning `Result` missing `# Errors` section
-regex-1.3.2/src/re_set.rs:94:5: docs for function returning `Result` missing `# Errors` section
-regex-1.3.2/src/re_trait.rs:136:29: redundant field names in struct initialization
-regex-1.3.2/src/re_unicode.rs:1019:9: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
-regex-1.3.2/src/re_unicode.rs:1041:9: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
-regex-1.3.2/src/re_unicode.rs:1088:13: redundant field names in struct initialization
-regex-1.3.2/src/re_unicode.rs:1135:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-regex-1.3.2/src/re_unicode.rs:1160:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-regex-1.3.2/src/re_unicode.rs:174:5: docs for function returning `Result` missing `# Errors` section
-regex-1.3.2/src/re_unicode.rs:21:1: this function could have a `#[must_use]` attribute
-regex-1.3.2/src/re_unicode.rs:313:13: redundant field names in struct initialization
-regex-1.3.2/src/re_unicode.rs:38:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/re_unicode.rs:44:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/re_unicode.rs:51:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/re_unicode.rs:57:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/re_unicode.rs:617:29: you should put `shortest_match` between ticks in the documentation
-regex-1.3.2/src/re_unicode.rs:631:29: you should put `is_match` between ticks in the documentation
-regex-1.3.2/src/re_unicode.rs:64:33: redundant field names in struct initialization
-regex-1.3.2/src/re_unicode.rs:64:47: redundant field names in struct initialization
-regex-1.3.2/src/re_unicode.rs:834:5: you should put `CaptureLocations` between ticks in the documentation
-regex-1.3.2/src/re_unicode.rs:860:1: item `re_unicode::CaptureLocations` has a public `len` method but no corresponding `is_empty` method
-regex-1.3.2/src/re_unicode.rs:866:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/re_unicode.rs:875:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/re_unicode.rs:886:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/re_unicode.rs:908:1: item `re_unicode::Captures<'t>` has a public `len` method but no corresponding `is_empty` method
-regex-1.3.2/src/re_unicode.rs:928:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/re_unicode.rs:934:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/re_unicode.rs:943:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/re_unicode.rs:972:5: this method could have a `#[must_use]` attribute
-regex-1.3.2/src/sparse.rs:10:37: you should put bare URLs between `<`/`>` or make a proper Markdown link
-regex-1.3.2/src/sparse.rs:15:1: item name starts with its containing module's name
-regex-1.3.2/src/utf8.rs:100:16: digits of hex or binary literal not grouped by four
-regex-1.3.2/src/utf8.rs:103:16: digits of hex or binary literal not grouped by four
-regex-1.3.2/src/utf8.rs:106:22: casting `u8` to `u32` may become silently lossy if you later change the type
-regex-1.3.2/src/utf8.rs:107:19: casting `u8` to `u32` may become silently lossy if you later change the type
-regex-1.3.2/src/utf8.rs:108:19: casting `u8` to `u32` may become silently lossy if you later change the type
-regex-1.3.2/src/utf8.rs:109:19: casting `u8` to `u32` may become silently lossy if you later change the type
-regex-1.3.2/src/utf8.rs:111:27: long literal lacking separators
-regex-1.3.2/src/utf8.rs:121:1: item name ends with its containing module's name
-regex-1.3.2/src/utf8.rs:143:24: digits of hex or binary literal not grouped by four
-regex-1.3.2/src/utf8.rs:143:9: digits of hex or binary literal not grouped by four
-regex-1.3.2/src/utf8.rs:23:1: item name ends with its containing module's name
-regex-1.3.2/src/utf8.rs:30:20: digits of hex or binary literal not grouped by four
-regex-1.3.2/src/utf8.rs:51:1: item name ends with its containing module's name
-regex-1.3.2/src/utf8.rs:58:23: digits of hex or binary literal not grouped by four
-regex-1.3.2/src/utf8.rs:58:9: digits of hex or binary literal not grouped by four
-regex-1.3.2/src/utf8.rs:63:16: digits of hex or binary literal not grouped by four
-regex-1.3.2/src/utf8.rs:66:22: casting `u8` to `u32` may become silently lossy if you later change the type
-regex-1.3.2/src/utf8.rs:66:54: casting `u8` to `u32` may become silently lossy if you later change the type
-regex-1.3.2/src/utf8.rs:77:16: digits of hex or binary literal not grouped by four
-regex-1.3.2/src/utf8.rs:80:16: digits of hex or binary literal not grouped by four
-regex-1.3.2/src/utf8.rs:83:22: casting `u8` to `u32` may become silently lossy if you later change the type
-regex-1.3.2/src/utf8.rs:84:19: casting `u8` to `u32` may become silently lossy if you later change the type
-regex-1.3.2/src/utf8.rs:85:19: casting `u8` to `u32` may become silently lossy if you later change the type
-regex-1.3.2/src/utf8.rs:92:23: digits of hex or binary literal not grouped by four
-regex-1.3.2/src/utf8.rs:92:9: digits of hex or binary literal not grouped by four
-regex-1.3.2/src/utf8.rs:97:16: digits of hex or binary literal not grouped by four
-ripgrep-12.1.1/build.rs:133:19: called `.as_ref().map(|x| &**x)` on an Option value. This can be done more directly by calling `githash.as_deref()` instead
-ripgrep-12.1.1/build.rs:18:18: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-ripgrep-12.1.1/build.rs:225:14: redundant closure found
-ripgrep-12.1.1/build.rs:92:19: called `.as_ref().map(|x| &**x)` on an Option value. This can be done more directly by calling `githash.as_deref()` instead
-ripgrep-12.1.1/crates/core/app.rs:1408:5: adding items after statements is confusing, since items exist from the start of the scope
-ripgrep-12.1.1/crates/core/app.rs:1408:5: adding items after statements is confusing, since items exist from the start of the scope
-ripgrep-12.1.1/crates/core/app.rs:1409:5: adding items after statements is confusing, since items exist from the start of the scope
-ripgrep-12.1.1/crates/core/app.rs:1409:5: adding items after statements is confusing, since items exist from the start of the scope
-ripgrep-12.1.1/crates/core/app.rs:152:32: you should put `clap::Arg` between ticks in the documentation
-ripgrep-12.1.1/crates/core/app.rs:152:32: you should put `clap::Arg` between ticks in the documentation
-ripgrep-12.1.1/crates/core/app.rs:156:39: you should put `clap::Arg` between ticks in the documentation
-ripgrep-12.1.1/crates/core/app.rs:156:39: you should put `clap::Arg` between ticks in the documentation
-ripgrep-12.1.1/crates/core/app.rs:156:5: you should put `RGArg` between ticks in the documentation
-ripgrep-12.1.1/crates/core/app.rs:156:5: you should put `RGArg` between ticks in the documentation
-ripgrep-12.1.1/crates/core/app.rs:1668:5: adding items after statements is confusing, since items exist from the start of the scope
-ripgrep-12.1.1/crates/core/app.rs:1668:5: adding items after statements is confusing, since items exist from the start of the scope
-ripgrep-12.1.1/crates/core/app.rs:1669:5: adding items after statements is confusing, since items exist from the start of the scope
-ripgrep-12.1.1/crates/core/app.rs:1669:5: adding items after statements is confusing, since items exist from the start of the scope
-ripgrep-12.1.1/crates/core/app.rs:1821:5: adding items after statements is confusing, since items exist from the start of the scope
-ripgrep-12.1.1/crates/core/app.rs:1821:5: adding items after statements is confusing, since items exist from the start of the scope
-ripgrep-12.1.1/crates/core/app.rs:1822:5: adding items after statements is confusing, since items exist from the start of the scope
-ripgrep-12.1.1/crates/core/app.rs:1822:5: adding items after statements is confusing, since items exist from the start of the scope
-ripgrep-12.1.1/crates/core/app.rs:2999:5: adding items after statements is confusing, since items exist from the start of the scope
-ripgrep-12.1.1/crates/core/app.rs:2999:5: adding items after statements is confusing, since items exist from the start of the scope
-ripgrep-12.1.1/crates/core/app.rs:3000:5: adding items after statements is confusing, since items exist from the start of the scope
-ripgrep-12.1.1/crates/core/app.rs:3000:5: adding items after statements is confusing, since items exist from the start of the scope
-ripgrep-12.1.1/crates/core/app.rs:367:54: this `match` has identical arm bodies
-ripgrep-12.1.1/crates/core/app.rs:367:54: this `match` has identical arm bodies
-ripgrep-12.1.1/crates/core/app.rs:414:59: this `match` has identical arm bodies
-ripgrep-12.1.1/crates/core/app.rs:414:59: this `match` has identical arm bodies
-ripgrep-12.1.1/crates/core/app.rs:417:57: this `match` has identical arm bodies
-ripgrep-12.1.1/crates/core/app.rs:417:57: this `match` has identical arm bodies
-ripgrep-12.1.1/crates/core/app.rs:417:57: this `match` has identical arm bodies
-ripgrep-12.1.1/crates/core/app.rs:417:57: this `match` has identical arm bodies
-ripgrep-12.1.1/crates/core/app.rs:444:41: this `match` has identical arm bodies
-ripgrep-12.1.1/crates/core/app.rs:444:41: this `match` has identical arm bodies
-ripgrep-12.1.1/crates/core/app.rs:470:41: this `match` has identical arm bodies
-ripgrep-12.1.1/crates/core/app.rs:470:41: this `match` has identical arm bodies
-ripgrep-12.1.1/crates/core/app.rs:75:9: you should put `RIPGREP_BUILD_GIT_HASH` between ticks in the documentation
-ripgrep-12.1.1/crates/core/app.rs:75:9: you should put `RIPGREP_BUILD_GIT_HASH` between ticks in the documentation
-ripgrep-12.1.1/crates/core/app.rs:87:5: unnecessary boolean `not` operation
-ripgrep-12.1.1/crates/core/app.rs:87:5: unnecessary boolean `not` operation
-ripgrep-12.1.1/crates/core/args.rs:1143:22: unused `self` argument
-ripgrep-12.1.1/crates/core/args.rs:11:1: this import is redundant
-ripgrep-12.1.1/crates/core/args.rs:1209:74: this `if` has identical blocks
-ripgrep-12.1.1/crates/core/args.rs:1209:74: this `if` has identical blocks
-ripgrep-12.1.1/crates/core/args.rs:1282:13: binding's name is too similar to existing binding
-ripgrep-12.1.1/crates/core/args.rs:1430:22: unused `self` argument
-ripgrep-12.1.1/crates/core/args.rs:1438:21: you should put `OsStr` between ticks in the documentation
-ripgrep-12.1.1/crates/core/args.rs:1520:44: redundant closure found
-ripgrep-12.1.1/crates/core/args.rs:1524:5: this function's return value is unnecessarily wrapped by `Result`
-ripgrep-12.1.1/crates/core/args.rs:1635:14: you should put `values_of_lossy` between ticks in the documentation
-ripgrep-12.1.1/crates/core/args.rs:1693:41: redundant closure found
-ripgrep-12.1.1/crates/core/args.rs:1770:17: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
-ripgrep-12.1.1/crates/core/args.rs:287:13: binding's name is too similar to existing binding
-ripgrep-12.1.1/crates/core/args.rs:33:1: this import is redundant
-ripgrep-12.1.1/crates/core/args.rs:34:1: this import is redundant
-ripgrep-12.1.1/crates/core/args.rs:35:1: this import is redundant
-ripgrep-12.1.1/crates/core/args.rs:410:14: this argument (2 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-ripgrep-12.1.1/crates/core/args.rs:475:18: this `match` has identical arm bodies
-ripgrep-12.1.1/crates/core/args.rs:512:19: you should put `ArgMatches` between ticks in the documentation
-ripgrep-12.1.1/crates/core/args.rs:549:16: methods called `to_*` usually take self by reference; consider choosing a less ambiguous name
-ripgrep-12.1.1/crates/core/args.rs:76:18: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-ripgrep-12.1.1/crates/core/args.rs:77:13: usage of wildcard import for enum variants
-ripgrep-12.1.1/crates/core/args.rs:923:42: you should put `BinaryDetection::quit` between ticks in the documentation
-ripgrep-12.1.1/crates/core/config.rs:13:1: this import is redundant
-ripgrep-12.1.1/crates/core/config.rs:58:6: very complex type used. Consider factoring parts into `type` definitions
-ripgrep-12.1.1/crates/core/config.rs:79:6: very complex type used. Consider factoring parts into `type` definitions
-ripgrep-12.1.1/crates/core/logger.rs:11:30: you should put `max_level` between ticks in the documentation
-ripgrep-12.1.1/crates/core/logger.rs:15:16: constants have by default a `'static` lifetime
-ripgrep-12.1.1/crates/core/main.rs:55:19: this argument is passed by value, but not consumed in the function body
-ripgrep-12.1.1/crates/core/main.rs:56:9: usage of wildcard import for enum variants
-ripgrep-12.1.1/crates/core/messages.rs:46:1: item name ends with its containing module's name
-ripgrep-12.1.1/crates/core/messages.rs:51:1: item name ends with its containing module's name
-ripgrep-12.1.1/crates/core/messages.rs:62:1: item name ends with its containing module's name
-ripgrep-12.1.1/crates/core/path_printer.rs:27:1: item name starts with its containing module's name
-ripgrep-12.1.1/crates/core/path_printer.rs:89:9: unnecessary boolean `not` operation
-ripgrep-12.1.1/crates/core/search.rs:185:1: item name starts with its containing module's name
-ripgrep-12.1.1/crates/core/search.rs:292:9: using `write!()` with a format string that ends in a single newline
-ripgrep-12.1.1/crates/core/search.rs:311:1: item name starts with its containing module's name
-ripgrep-12.1.1/crates/core/search.rs:377:12: this boolean expression can be simplified
-ripgrep-12.1.1/crates/core/search.rs:423:13: usage of wildcard import for enum variants
-ripgrep-12.1.1/crates/core/search.rs:447:13: usage of wildcard import for enum variants
-ripgrep-12.1.1/crates/core/search.rs:472:24: you are using an explicit closure for cloning elements
-ripgrep-12.1.1/crates/core/search.rs:472:41: redundant closure found
-ripgrep-12.1.1/crates/core/search.rs:480:24: you are using an explicit closure for cloning elements
-ripgrep-12.1.1/crates/core/search.rs:480:41: redundant closure found
-ripgrep-12.1.1/crates/core/search.rs:49:1: item name starts with its containing module's name
-ripgrep-12.1.1/crates/core/search.rs:509:24: you are using an explicit closure for cloning elements
-ripgrep-12.1.1/crates/core/search.rs:509:41: redundant closure found
-ripgrep-12.1.1/crates/core/search.rs:517:24: you are using an explicit closure for cloning elements
-ripgrep-12.1.1/crates/core/search.rs:517:41: redundant closure found
-ripgrep-12.1.1/crates/core/search.rs:533:36: casting `u32` to `f64` may become silently lossy if you later change the type
-ripgrep-12.1.1/crates/core/search.rs:533:5: casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-ripgrep-12.1.1/crates/core/subject.rs:20:1: item name starts with its containing module's name
-ripgrep-12.1.1/crates/core/subject.rs:4:1: this import is redundant
-syn-1.0.54/src/lit.rs:1397:40: redundant else block
-syn-1.0.54/src/lit.rs:1405:28: redundant else block
-syn-1.0.54/src/lit.rs:1485:32: redundant else block
-unicode-xid-0.2.1/src/lib.rs:57:64: you should put `XID_Start` between ticks in the documentation
-unicode-xid-0.2.1/src/lib.rs:60:10: you should put `XID_Start` between ticks in the documentation
-unicode-xid-0.2.1/src/lib.rs:62:27: you should put `ID_Start` between ticks in the documentation
-unicode-xid-0.2.1/src/lib.rs:62:67: you should put `NFKx` between ticks in the documentation
-unicode-xid-0.2.1/src/lib.rs:63:21: methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name
-unicode-xid-0.2.1/src/lib.rs:65:61: you should put `XID_Continue` between ticks in the documentation
-unicode-xid-0.2.1/src/lib.rs:68:10: you should put `XID_Continue` between ticks in the documentation
-unicode-xid-0.2.1/src/lib.rs:70:28: you should put `ID_Continue` between ticks in the documentation
-unicode-xid-0.2.1/src/lib.rs:70:72: you should put `NFKx` between ticks in the documentation
-unicode-xid-0.2.1/src/lib.rs:71:24: methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name
-xsv-0.13.0/src/cmd/cat.rs:101:34: redundant closure found
-xsv-0.13.0/src/cmd/cat.rs:42:1: more than 3 bools in a struct
-xsv-0.13.0/src/cmd/cat.rs:53:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/cat.rs:7:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/count.rs:32:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/count.rs:38:9: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-xsv-0.13.0/src/cmd/count.rs:42:33: integer type suffix should be separated by an underscore
-xsv-0.13.0/src/cmd/count.rs:50:5: passing a unit value to a function
-xsv-0.13.0/src/cmd/count.rs:7:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/fixlengths.rs:45:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/fixlengths.rs:50:18: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-xsv-0.13.0/src/cmd/fixlengths.rs:62:30: integer type suffix should be separated by an underscore
-xsv-0.13.0/src/cmd/fixlengths.rs:9:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/flatten.rs:10:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/flatten.rs:51:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/fmt.rs:50:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/fmt.rs:55:13: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/fmt.rs:7:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/frequency.rs:148:43: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
-xsv-0.13.0/src/cmd/frequency.rs:149:43: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
-xsv-0.13.0/src/cmd/frequency.rs:15:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/frequency.rs:169:13: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/frequency.rs:176:17: unnecessary boolean `not` operation
-xsv-0.13.0/src/cmd/frequency.rs:178:24: this `else { if .. }` block can be collapsed
-xsv-0.13.0/src/cmd/frequency.rs:77:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/frequency.rs:93:31: it is more concise to loop over containers instead of using explicit iteration methods
-xsv-0.13.0/src/cmd/headers.rs:43:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/headers.rs:49:17: it is more concise to loop over containers instead of using explicit iteration methods
-xsv-0.13.0/src/cmd/headers.rs:60:22: trait objects without an explicit `dyn` are deprecated
-xsv-0.13.0/src/cmd/headers.rs:9:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/index.rs:11:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/index.rs:45:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/input.rs:42:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/input.rs:47:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/input.rs:7:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/join.rs:17:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/join.rs:194:29: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/join.rs:224:22: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/join.rs:281:44: trait objects without an explicit `dyn` are deprecated
-xsv-0.13.0/src/cmd/join.rs:293:14: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/join.rs:293:20: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/join.rs:297:13: redundant field names in struct initialization
-xsv-0.13.0/src/cmd/join.rs:298:13: redundant field names in struct initialization
-xsv-0.13.0/src/cmd/join.rs:299:13: redundant field names in struct initialization
-xsv-0.13.0/src/cmd/join.rs:300:13: redundant field names in struct initialization
-xsv-0.13.0/src/cmd/join.rs:308:9: unused `self` argument
-xsv-0.13.0/src/cmd/join.rs:342:38: integer type suffix should be separated by an underscore
-xsv-0.13.0/src/cmd/join.rs:342:46: integer type suffix should be separated by an underscore
-xsv-0.13.0/src/cmd/join.rs:347:9: unnecessary boolean `not` operation
-xsv-0.13.0/src/cmd/join.rs:372:44: redundant closure found
-xsv-0.13.0/src/cmd/join.rs:375:33: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/join.rs:392:13: redundant field names in struct initialization
-xsv-0.13.0/src/cmd/join.rs:403:29: it is more concise to loop over containers instead of using explicit iteration methods
-xsv-0.13.0/src/cmd/join.rs:426:13: unnecessary boolean `not` operation
-xsv-0.13.0/src/cmd/join.rs:77:1: more than 3 bools in a struct
-xsv-0.13.0/src/cmd/join.rs:94:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/partition.rs:105:22: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/partition.rs:126:36: trait objects without an explicit `dyn` are deprecated
-xsv-0.13.0/src/cmd/partition.rs:139:13: redundant field names in struct initialization
-xsv-0.13.0/src/cmd/partition.rs:15:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/partition.rs:169:9: unnecessary boolean `not` operation
-xsv-0.13.0/src/cmd/partition.rs:56:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/partition.rs:77:9: unused `self` argument
-xsv-0.13.0/src/cmd/sample.rs:105:44: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
-xsv-0.13.0/src/cmd/sample.rs:115:21: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
-xsv-0.13.0/src/cmd/sample.rs:11:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/sample.rs:51:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/sample.rs:58:19: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-xsv-0.13.0/src/cmd/sample.rs:69:9: wildcard match will miss any future added variants
-xsv-0.13.0/src/cmd/sample.rs:75:16: it is more concise to loop over containers instead of using explicit iteration methods
-xsv-0.13.0/src/cmd/sample.rs:91:42: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
-xsv-0.13.0/src/cmd/sample.rs:92:43: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
-xsv-0.13.0/src/cmd/search.rs:51:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/search.rs:9:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/select.rs:60:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/select.rs:8:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/slice.rs:57:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/slice.rs:9:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/sort.rs:11:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/sort.rs:138:47: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-xsv-0.13.0/src/cmd/sort.rs:139:51: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-xsv-0.13.0/src/cmd/sort.rs:48:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/sort.rs:91:14: it is more concise to loop over containers instead of using explicit iteration methods
-xsv-0.13.0/src/cmd/split.rs:131:36: trait objects without an explicit `dyn` are deprecated
-xsv-0.13.0/src/cmd/split.rs:14:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/split.rs:61:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/split.rs:94:5: this function's return value is unnecessarily wrapped by `Result`
-xsv-0.13.0/src/cmd/split.rs:96:14: this argument is passed by value, but not consumed in the function body
-xsv-0.13.0/src/cmd/split.rs:99:13: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
-xsv-0.13.0/src/cmd/stats.rs:110:36: redundant closure found
-xsv-0.13.0/src/cmd/stats.rs:127:14: this argument is passed by value, but not consumed in the function body
-xsv-0.13.0/src/cmd/stats.rs:138:43: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
-xsv-0.13.0/src/cmd/stats.rs:139:43: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
-xsv-0.13.0/src/cmd/stats.rs:162:25: it is more concise to loop over containers instead of using explicit iteration methods
-xsv-0.13.0/src/cmd/stats.rs:22:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/stats.rs:231:1: more than 3 bools in a struct
-xsv-0.13.0/src/cmd/stats.rs:262:35: calling `cmd::stats::TypedSum::default()` is more clear than this expression
-xsv-0.13.0/src/cmd/stats.rs:263:40: calling `cmd::stats::TypedMinMax::default()` is more clear than this expression
-xsv-0.13.0/src/cmd/stats.rs:264:39: calling `stats::OnlineStats::default()` is more clear than this expression
-xsv-0.13.0/src/cmd/stats.rs:265:58: calling `stats::Unsorted::default()` is more clear than this expression
-xsv-0.13.0/src/cmd/stats.rs:266:41: calling `stats::Unsorted::default()` is more clear than this expression
-xsv-0.13.0/src/cmd/stats.rs:268:18: calling `cmd::stats::FieldType::default()` is more clear than this expression
-xsv-0.13.0/src/cmd/stats.rs:269:13: redundant field names in struct initialization
-xsv-0.13.0/src/cmd/stats.rs:270:13: redundant field names in struct initialization
-xsv-0.13.0/src/cmd/stats.rs:271:13: redundant field names in struct initialization
-xsv-0.13.0/src/cmd/stats.rs:272:13: redundant field names in struct initialization
-xsv-0.13.0/src/cmd/stats.rs:273:13: redundant field names in struct initialization
-xsv-0.13.0/src/cmd/stats.rs:274:13: redundant field names in struct initialization
-xsv-0.13.0/src/cmd/stats.rs:283:9: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-xsv-0.13.0/src/cmd/stats.rs:284:9: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-xsv-0.13.0/src/cmd/stats.rs:285:9: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-xsv-0.13.0/src/cmd/stats.rs:290:21: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-xsv-0.13.0/src/cmd/stats.rs:293:25: this `match` has identical arm bodies
-xsv-0.13.0/src/cmd/stats.rs:297:25: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-xsv-0.13.0/src/cmd/stats.rs:301:21: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-xsv-0.13.0/src/cmd/stats.rs:302:21: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-xsv-0.13.0/src/cmd/stats.rs:308:18: methods called `to_*` usually take self by reference; consider choosing a less ambiguous name
-xsv-0.13.0/src/cmd/stats.rs:318:9: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-xsv-0.13.0/src/cmd/stats.rs:322:45: redundant closure found
-xsv-0.13.0/src/cmd/stats.rs:322:9: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-xsv-0.13.0/src/cmd/stats.rs:327:9: unnecessary boolean `not` operation
-xsv-0.13.0/src/cmd/stats.rs:330:13: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-xsv-0.13.0/src/cmd/stats.rs:338:45: redundant closure found
-xsv-0.13.0/src/cmd/stats.rs:402:16: redundant pattern matching, consider using `is_ok()`
-xsv-0.13.0/src/cmd/stats.rs:403:16: redundant pattern matching, consider using `is_ok()`
-xsv-0.13.0/src/cmd/stats.rs:407:18: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-xsv-0.13.0/src/cmd/stats.rs:411:16: this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-xsv-0.13.0/src/cmd/stats.rs:427:56: this `match` has identical arm bodies
-xsv-0.13.0/src/cmd/stats.rs:429:56: this `match` has identical arm bodies
-xsv-0.13.0/src/cmd/stats.rs:430:60: this `match` has identical arm bodies
-xsv-0.13.0/src/cmd/stats.rs:430:60: this `match` has identical arm bodies
-xsv-0.13.0/src/cmd/stats.rs:454:5: you should put `TypedSum` between ticks in the documentation
-xsv-0.13.0/src/cmd/stats.rs:473:43: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-xsv-0.13.0/src/cmd/stats.rs:504:56: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-xsv-0.13.0/src/cmd/stats.rs:505:51: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-xsv-0.13.0/src/cmd/stats.rs:511:5: you should put `TypedMinMax` between ticks in the documentation
-xsv-0.13.0/src/cmd/stats.rs:536:35: casting `f64` to `i64` may truncate the value
-xsv-0.13.0/src/cmd/stats.rs:544:33: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-xsv-0.13.0/src/cmd/stats.rs:592:22: calling `stats::MinMax::default()` is more clear than this expression
-xsv-0.13.0/src/cmd/stats.rs:593:22: calling `stats::MinMax::default()` is more clear than this expression
-xsv-0.13.0/src/cmd/stats.rs:594:23: calling `stats::MinMax::default()` is more clear than this expression
-xsv-0.13.0/src/cmd/stats.rs:595:21: calling `stats::MinMax::default()` is more clear than this expression
-xsv-0.13.0/src/cmd/stats.rs:71:1: more than 3 bools in a struct
-xsv-0.13.0/src/cmd/stats.rs:86:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/table.rs:10:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/cmd/table.rs:50:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/cmd/table.rs:54:9: binding's name is too similar to existing binding
-xsv-0.13.0/src/config.rs:113:43: use of `unwrap_or` followed by a function call
-xsv-0.13.0/src/config.rs:197:48: trait objects without an explicit `dyn` are deprecated
-xsv-0.13.0/src/config.rs:202:48: trait objects without an explicit `dyn` are deprecated
-xsv-0.13.0/src/config.rs:263:47: trait objects without an explicit `dyn` are deprecated
-xsv-0.13.0/src/config.rs:293:47: trait objects without an explicit `dyn` are deprecated
-xsv-0.13.0/src/config.rs:58:1: more than 3 bools in a struct
-xsv-0.13.0/src/config.rs:77:28: explicit deref method call
-xsv-0.13.0/src/config.rs:90:13: redundant field names in struct initialization
-xsv-0.13.0/src/index.rs:31:13: redundant field names in struct initialization
-xsv-0.13.0/src/main.rs:164:49: redundant clone
-xsv-0.13.0/src/main.rs:75:16: statics have by default a `'static` lifetime
-xsv-0.13.0/src/select.rs:13:1: item name starts with its containing module's name
-xsv-0.13.0/src/select.rs:154:5: this function's return value is unnecessarily wrapped by `Result`
-xsv-0.13.0/src/select.rs:250:33: binding's name is too similar to existing binding
-xsv-0.13.0/src/select.rs:250:43: binding's name is too similar to existing binding
-xsv-0.13.0/src/select.rs:255:39: an inclusive range would be more readable
-xsv-0.13.0/src/select.rs:280:20: length comparison to zero
-xsv-0.13.0/src/select.rs:29:13: redundant field names in struct initialization
-xsv-0.13.0/src/select.rs:360:62: this argument (8 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-xsv-0.13.0/src/select.rs:360:9: this function's return value is unnecessarily wrapped by `Option`
-xsv-0.13.0/src/select.rs:375:9: used sort instead of sort_unstable to sort primitive type `usize`
-xsv-0.13.0/src/select.rs:379:18: it is more concise to loop over containers instead of using explicit iteration methods
-xsv-0.13.0/src/select.rs:416:5: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-xsv-0.13.0/src/select.rs:419:9: this function's return value is unnecessarily wrapped by `Option`
-xsv-0.13.0/src/select.rs:420:27: consider using `Option<T>` instead of `Option<Option<T>>` or a custom enum if you need to distinguish all 3 cases
-xsv-0.13.0/src/select.rs:99:17: binding's name is too similar to existing binding
-xsv-0.13.0/src/util.rs:150:5: you should put bare URLs between `<`/`>` or make a proper Markdown link
-xsv-0.13.0/src/util.rs:190:48: trait objects without an explicit `dyn` are deprecated
-xsv-0.13.0/src/util.rs:37:33: you are using an explicit closure for copying elements
-xsv-0.13.0/src/util.rs:90:1: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+cargo/0.49.0//home/matthias/.rustup/toolchains/nightly-2020-12-20-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:393:34 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/build.rs:1:null clippy::cargo_common_metadata "package `cargo` is missing `package.categories` metadata"
+cargo/0.49.0/build.rs:1:null clippy::cargo_common_metadata "package `cargo` is missing `package.keywords` metadata"
+cargo/0.49.0/src/bin/cargo/cli.rs:104:34 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/bin/cargo/cli.rs:121:5 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
+cargo/0.49.0/src/bin/cargo/cli.rs:157:30 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/bin/cargo/cli.rs:184:41 clippy::cast_possible_truncation "casting `u64` to `u32` may truncate the value"
+cargo/0.49.0/src/bin/cargo/cli.rs:196:42 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/bin/cargo/cli.rs:200:39 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/bin/cargo/cli.rs:231:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+cargo/0.49.0/src/bin/cargo/cli.rs:245:22 clippy::cast_possible_truncation "casting `u64` to `u32` may truncate the value"
+cargo/0.49.0/src/bin/cargo/cli.rs:247:47 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/bin/cargo/cli.rs:257:22 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/bin/cargo/cli.rs:26:20 clippy::redundant_else "redundant else block"
+cargo/0.49.0/src/bin/cargo/cli.rs:7:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/commands/bench.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/commands/bench.rs:76:59 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/bin/cargo/commands/build.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/commands/check.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/commands/clean.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/commands/doc.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/commands/fetch.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/commands/fix.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/commands/generate_lockfile.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/commands/git_checkout.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/commands/help.rs:20:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo/0.49.0/src/bin/cargo/commands/init.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/commands/install.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/commands/install.rs:97:16 clippy::option_if_let_else "use Option::map_or instead of an if let/else"
+cargo/0.49.0/src/bin/cargo/commands/locate_project.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/commands/login.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/commands/metadata.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/commands/mod.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/commands/new.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/commands/new.rs:20:24 clippy::option_if_let_else "use Option::map_or instead of an if let/else"
+cargo/0.49.0/src/bin/cargo/commands/owner.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/commands/owner.rs:38:43 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/bin/cargo/commands/owner.rs:39:43 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/bin/cargo/commands/owner.rs:40:43 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/bin/cargo/commands/owner.rs:43:30 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/bin/cargo/commands/owner.rs:46:30 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/bin/cargo/commands/package.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/commands/pkgid.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/commands/publish.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/commands/publish.rs:40:47 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/bin/cargo/commands/read_manifest.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/commands/run.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/commands/rustc.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/commands/rustdoc.rs:3:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/commands/search.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/commands/test.rs:127:54 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/bin/cargo/commands/test.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/commands/tree.rs:149:49 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/bin/cargo/commands/tree.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/commands/uninstall.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/commands/update.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/commands/vendor.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/commands/vendor.rs:96:16 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
+cargo/0.49.0/src/bin/cargo/commands/verify_project.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/commands/version.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/commands/yank.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/commands/yank.rs:32:36 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/bin/cargo/commands/yank.rs:33:35 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/bin/cargo/commands/yank.rs:34:36 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/bin/cargo/commands/yank.rs:35:36 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/bin/cargo/main.rs:100:17 clippy::match_wildcard_for_single_variants "wildcard match will miss any future added variants"
+cargo/0.49.0/src/bin/cargo/main.rs:118:41 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/bin/cargo/main.rs:137:43 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/bin/cargo/main.rs:148:19 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/bin/cargo/main.rs:174:57 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/bin/cargo/main.rs:18:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/bin/cargo/main.rs:1:null clippy::cargo_common_metadata "package `cargo` is missing `package.categories` metadata"
+cargo/0.49.0/src/bin/cargo/main.rs:1:null clippy::cargo_common_metadata "package `cargo` is missing `package.keywords` metadata"
+cargo/0.49.0/src/bin/cargo/main.rs:1:null clippy::multiple_crate_versions "multiple versions for dependency `crossbeam-utils`: 0.6.6, 0.7.2"
+cargo/0.49.0/src/bin/cargo/main.rs:1:null clippy::multiple_crate_versions "multiple versions for dependency `hex`: 0.3.2, 0.4.0"
+cargo/0.49.0/src/bin/cargo/main.rs:1:null clippy::multiple_crate_versions "multiple versions for dependency `humantime`: 1.3.0, 2.0.0"
+cargo/0.49.0/src/bin/cargo/main.rs:72:22 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/bin/cargo/main.rs:94:13 clippy::match_wildcard_for_single_variants "wildcard match will miss any future added variants"
+cargo/0.49.0/src/bin/cargo/main.rs:96:41 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/bin/cargo/main.rs:98:60 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/compiler/build_config.rs:155:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+cargo/0.49.0/src/cargo/core/compiler/build_config.rs:170:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/compiler/build_config.rs:175:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/compiler/build_config.rs:180:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/compiler/build_config.rs:186:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/compiler/build_config.rs:197:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/compiler/build_config.rs:205:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/compiler/build_config.rs:51:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/compiler/build_config.rs:69:48 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+cargo/0.49.0/src/cargo/core/compiler/build_config.rs:96:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/compiler/build_context/mod.rs:44:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/compiler/build_context/mod.rs:83:20 clippy::doc_markdown "you should put `x86_64` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:108:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:121:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:149:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:420:69 clippy::doc_markdown "you should put `mode/target_kind` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:423:19 clippy::doc_markdown "you should put `CrateTypes` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:424:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:469:58 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:591:20 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:603:19 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:665:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:82:31 clippy::doc_markdown "you should put `FileType` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:83:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:84:9 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:96:31 clippy::doc_markdown "you should put `FileType` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:98:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/compiler/build_plan.rs:4:9 clippy::doc_markdown "you should put `BuildPlan` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/compiler/build_plan.rs:5:66 clippy::doc_markdown "you should put `BuildPlan` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/compiler/compilation.rs:150:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/compiler/compilation.rs:169:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/compiler/compilation.rs:185:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/compiler/compilation.rs:193:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/compiler/compilation.rs:194:49 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/compiler/compilation.rs:198:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/compiler/compilation.rs:314:16 clippy::doc_markdown "you should put `rustc_tool` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/compiler/compilation.rs:91:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/compiler/compile_kind.rs:118:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/compiler/compile_kind.rs:147:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/compiler/compile_kind.rs:157:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/compiler/compile_kind.rs:29:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/compiler/compile_kind.rs:33:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/compiler/compile_kind.rs:49:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/compiler/context/compilation_files.rs:204:9 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/compiler/context/compilation_files.rs:277:22 clippy::doc_markdown "you should put `OUT_DIR` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/compiler/context/compilation_files.rs:324:66 clippy::doc_markdown "you should put `FileType` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/compiler/context/compilation_files.rs:393:37 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/core/compiler/context/compilation_files.rs:426:71 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:125:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:125:5 clippy::too_many_lines "this function has too many lines (107/100)"
+cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:270:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:286:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:308:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:340:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:349:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:354:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:358:21 clippy::doc_markdown "you should put `RunCustomBuild` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:361:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:365:9 clippy::find_map "called `find(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:374:43 clippy::doc_markdown "you should put `RunCustomBuild` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:378:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:383:41 clippy::doc_markdown "you should put `RunCustomBuild` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:384:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:391:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:397:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:523:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:538:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:542:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:83:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:92:25 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/compiler/crate_type.rs:16:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/compiler/crate_type.rs:29:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/compiler/crate_type.rs:40:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/compiler/crate_type.rs:49:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/compiler/crate_type.rs:60:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:150:1 clippy::too_many_lines "this function has too many lines (230/100)"
+cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:154:29 clippy::find_map "called `find(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:353:56 clippy::manual_strip "stripping a prefix manually"
+cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:448:27 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:464:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:481:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:48:56 clippy::doc_markdown "you should put `RunCustomBuild` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:561:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:567:20 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:576:28 clippy::shadow_unrelated "`mut value` is being shadowed"
+cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:606:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:624:13 clippy::find_map "called `find(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:688:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:756:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:762:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:762:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:823:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1021:51 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1252:20 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1278:19 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1656:16 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1664:5 clippy::field_reassign_with_default "field assignment outside of initializer for an instance created with Default::default()"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1787:5 clippy::similar_names "binding's name is too similar to existing binding"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1795:5 clippy::field_reassign_with_default "field assignment outside of initializer for an instance created with Default::default()"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1882:17 clippy::similar_names "binding's name is too similar to existing binding"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1894:17 clippy::similar_names "binding's name is too similar to existing binding"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1906:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1917:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1923:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1956:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1962:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1963:22 clippy::cast_possible_truncation "casting `usize` to `u8` may truncate the value"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1964:22 clippy::cast_possible_truncation "casting `usize` to `u8` may truncate the value"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1965:22 clippy::cast_possible_truncation "casting `usize` to `u8` may truncate the value"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1966:22 clippy::cast_possible_truncation "casting `usize` to `u8` may truncate the value"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1980:17 clippy::similar_names "binding's name is too similar to existing binding"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1980:24 clippy::manual_strip "stripping a prefix manually"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1986:17 clippy::similar_names "binding's name is too similar to existing binding"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:2016:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:61:5 clippy::doc_markdown "you should put `CompileMode` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:63:12 clippy::doc_markdown "you should put `CompileKind` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:67:7 clippy::doc_markdown "you should put `CARGO_DEFAULT_LIB_METADATA[^4` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:68:5 clippy::doc_markdown "you should put `package_id` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:71:19 clippy::doc_markdown "you should put `test/bench/for_host/edition` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:755:52 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:77:5 clippy::doc_markdown "you should put `is_std` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:816:5 clippy::too_many_lines "this function has too many lines (127/100)"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:863:64 clippy::similar_names "binding's name is too similar to existing binding"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:875:33 clippy::similar_names "binding's name is too similar to existing binding"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:876:32 clippy::similar_names "binding's name is too similar to existing binding"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:896:30 clippy::similar_names "binding's name is too similar to existing binding"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:897:30 clippy::similar_names "binding's name is too similar to existing binding"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:991:37 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:12:5 clippy::doc_markdown "you should put `src/librustc_jobserver/lib.rs` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:282:30 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:329:13 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:332:23 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:34:53 clippy::doc_markdown "you should put `NeedsToken` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:35:6 clippy::doc_markdown "you should put `ReleaseToken` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:37:6 clippy::doc_markdown "you should put `NeedsToken` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:40:5 clippy::doc_markdown "you should put `NeedsToken` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:40:56 clippy::doc_markdown "you should put `NeedsToken` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:43:6 clippy::doc_markdown "you should put `ReleaseToken` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:749:13 clippy::if_not_else "unnecessary boolean `not` operation"
+cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:786:26 clippy::unused_self "unused `self` argument"
+cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:81:61 clippy::doc_markdown "you should put `DrainState` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:865:13 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:871:13 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:890:9 clippy::unused_self "unused `self` argument"
+cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:93:24 clippy::doc_markdown "you should put `JobQueue` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/compiler/links.rs:8:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo/0.49.0/src/cargo/core/compiler/mod.rs:1016:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/compiler/mod.rs:1094:19 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/compiler/mod.rs:1131:1 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+cargo/0.49.0/src/cargo/core/compiler/mod.rs:1277:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/core/compiler/mod.rs:179:1 clippy::too_many_lines "this function has too many lines (162/100)"
+cargo/0.49.0/src/cargo/core/compiler/mod.rs:198:78 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/compiler/mod.rs:201:25 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/compiler/mod.rs:267:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/core/compiler/mod.rs:324:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/core/compiler/mod.rs:364:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/core/compiler/mod.rs:364:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+cargo/0.49.0/src/cargo/core/compiler/mod.rs:392:45 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/compiler/mod.rs:415:23 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/compiler/mod.rs:667:15 clippy::similar_names "binding's name is too similar to existing binding"
+cargo/0.49.0/src/cargo/core/compiler/mod.rs:693:1 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+cargo/0.49.0/src/cargo/core/compiler/mod.rs:725:42 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/core/compiler/mod.rs:736:1 clippy::too_many_lines "this function has too many lines (141/100)"
+cargo/0.49.0/src/cargo/core/compiler/mod.rs:73:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/compiler/mod.rs:777:12 clippy::if_not_else "unnecessary boolean `not` operation"
+cargo/0.49.0/src/cargo/core/compiler/mod.rs:873:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/core/compiler/output_depinfo.rs:41:13 clippy::match_wildcard_for_single_variants "wildcard match will miss any future added variants"
+cargo/0.49.0/src/cargo/core/compiler/rustdoc.rs:16:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/core/compiler/rustdoc.rs:57:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/core/compiler/rustdoc.rs:72:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/compiler/standard_lib.rs:134:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/compiler/standard_lib.rs:16:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/compiler/standard_lib.rs:30:28 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/compiler/standard_lib.rs:34:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/compiler/timings.rs:16:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+cargo/0.49.0/src/cargo/core/compiler/timings.rs:192:64 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+cargo/0.49.0/src/cargo/core/compiler/timings.rs:212:58 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+cargo/0.49.0/src/cargo/core/compiler/timings.rs:234:13 clippy::let_underscore_drop "non-binding `let` on a type that implements `Drop`"
+cargo/0.49.0/src/cargo/core/compiler/timings.rs:355:13 clippy::cast_possible_truncation "casting `f64` to `u32` may truncate the value"
+cargo/0.49.0/src/cargo/core/compiler/timings.rs:355:13 clippy::cast_sign_loss "casting `f64` to `u32` may lose the sign of the value"
+cargo/0.49.0/src/cargo/core/compiler/timings.rs:397:38 clippy::cast_possible_truncation "casting `f64` to `u32` may truncate the value"
+cargo/0.49.0/src/cargo/core/compiler/timings.rs:397:38 clippy::cast_sign_loss "casting `f64` to `u32` may lose the sign of the value"
+cargo/0.49.0/src/cargo/core/compiler/timings.rs:484:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/core/compiler/timings.rs:605:38 clippy::doc_markdown "you should put `rmeta_time` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/compiler/timings.rs:605:50 clippy::doc_markdown "you should put `codegen_time` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/compiler/timings.rs:641:26 clippy::non_ascii_literal "literal non-ASCII character detected"
+cargo/0.49.0/src/cargo/core/compiler/unit.rs:100:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/compiler/unit.rs:151:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/core/compiler/unit.rs:161:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/compiler/unit.rs:35:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/core/compiler/unit_dependencies.rs:154:29 clippy::doc_markdown "you should put `state.unit_dependencies` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/compiler/unit_dependencies.rs:213:1 clippy::too_many_lines "this function has too many lines (110/100)"
+cargo/0.49.0/src/cargo/core/compiler/unit_dependencies.rs:329:13 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/core/compiler/unit_dependencies.rs:480:5 clippy::find_map "called `find(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/core/compiler/unit_dependencies.rs:511:5 clippy::find_map "called `find(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/core/compiler/unit_dependencies.rs:52:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/compiler/unit_dependencies.rs:52:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo/0.49.0/src/cargo/core/compiler/unit_graph.rs:65:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/compiler/unit_graph.rs:65:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo/0.49.0/src/cargo/core/dependency.rs:157:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/dependency.rs:182:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/dependency.rs:203:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/dependency.rs:224:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/dependency.rs:23:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+cargo/0.49.0/src/cargo/core/dependency.rs:248:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/dependency.rs:270:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/dependency.rs:274:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/dependency.rs:278:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/dependency.rs:287:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/dependency.rs:291:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/dependency.rs:305:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/dependency.rs:311:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/dependency.rs:319:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/dependency.rs:337:75 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/dependency.rs:397:56 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/dependency.rs:403:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/dependency.rs:408:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/dependency.rs:415:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/dependency.rs:419:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/dependency.rs:424:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/dependency.rs:428:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/dependency.rs:433:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/dependency.rs:438:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/dependency.rs:443:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/dependency.rs:449:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/dependency.rs:450:9 clippy::if_not_else "unnecessary `!=` operation"
+cargo/0.49.0/src/cargo/core/features.rs:119:17 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/features.rs:229:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/features.rs:274:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/features.rs:278:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/features.rs:306:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/features.rs:338:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+cargo/0.49.0/src/cargo/core/features.rs:362:25 clippy::option_option "consider using `Option<T>` instead of `Option<Option<T>>` or a custom enum if you need to distinguish all 3 cases"
+cargo/0.49.0/src/cargo/core/features.rs:380:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/features.rs:401:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/core/features.rs:409:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/core/features.rs:412:45 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/features.rs:416:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/core/features.rs:419:45 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/features.rs:424:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/core/features.rs:431:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/core/features.rs:477:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/features.rs:509:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/features.rs:518:5 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
+cargo/0.49.0/src/cargo/core/features.rs:542:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/features.rs:543:37 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/features.rs:547:60 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/features.rs:556:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo/0.49.0/src/cargo/core/features.rs:563:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo/0.49.0/src/cargo/core/manifest.rs:116:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+cargo/0.49.0/src/cargo/core/manifest.rs:118:58 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/manifest.rs:130:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+cargo/0.49.0/src/cargo/core/manifest.rs:143:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:159:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:162:34 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/manifest.rs:169:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:17:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/cargo/core/manifest.rs:189:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+cargo/0.49.0/src/cargo/core/manifest.rs:215:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:222:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:22:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo/0.49.0/src/cargo/core/manifest.rs:360:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:407:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:410:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:413:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:416:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:419:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:422:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:425:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:431:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:438:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:444:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:447:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:450:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:453:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:456:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:459:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:462:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:466:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:470:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:477:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:481:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:488:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/manifest.rs:512:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:516:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:520:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:524:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:528:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:538:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:557:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:561:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:565:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:569:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:577:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:581:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:588:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:617:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:632:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:648:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:659:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:66:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo/0.49.0/src/cargo/core/manifest.rs:670:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:693:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:708:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:723:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:726:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:729:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:735:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:738:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:741:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:744:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:747:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:751:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:754:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:757:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:760:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:763:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:767:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:776:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:780:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:787:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:798:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:800:56 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/manifest.rs:805:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:809:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:818:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:823:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:828:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:831:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:834:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:839:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:85:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/core/manifest.rs:888:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/manifest.rs:936:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/package.rs:1075:28 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/package.rs:160:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/package.rs:170:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/package.rs:174:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/package.rs:182:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/package.rs:186:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/package.rs:190:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/package.rs:194:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/package.rs:198:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/package.rs:202:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/package.rs:206:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/package.rs:210:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/package.rs:217:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/package.rs:221:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/package.rs:222:35 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/package.rs:226:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/package.rs:227:35 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/package.rs:230:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/package.rs:239:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/package.rs:249:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/package.rs:287:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/core/package.rs:385:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/package.rs:421:5 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
+cargo/0.49.0/src/cargo/core/package.rs:425:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/package.rs:452:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/package.rs:453:60 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/package.rs:459:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/package.rs:473:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/package.rs:587:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/package.rs:682:46 clippy::cast_possible_truncation "casting `f64` to `u64` may truncate the value"
+cargo/0.49.0/src/cargo/core/package.rs:682:46 clippy::cast_sign_loss "casting `f64` to `u64` may lose the sign of the value"
+cargo/0.49.0/src/cargo/core/package.rs:682:63 clippy::cast_possible_truncation "casting `f64` to `u64` may truncate the value"
+cargo/0.49.0/src/cargo/core/package.rs:682:63 clippy::cast_sign_loss "casting `f64` to `u64` may lose the sign of the value"
+cargo/0.49.0/src/cargo/core/package.rs:731:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/package.rs:790:13 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/package.rs:988:9 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/package_id.rs:115:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/package_id.rs:124:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/package_id.rs:139:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/package_id.rs:142:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/package_id.rs:145:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/package_id.rs:149:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/package_id.rs:157:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/package_id.rs:161:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/package_id.rs:169:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/package_id.rs:174:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/core/package_id_spec.rs:101:39 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/package_id_spec.rs:143:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/package_id_spec.rs:147:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/package_id_spec.rs:151:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/package_id_spec.rs:160:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/package_id_spec.rs:179:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/package_id_spec.rs:212:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/core/package_id_spec.rs:231:9 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/package_id_spec.rs:51:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/package_id_spec.rs:77:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/package_id_spec.rs:88:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/profiles.rs:1004:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/profiles.rs:1014:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/profiles.rs:1018:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/profiles.rs:1028:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/profiles.rs:106:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/core/profiles.rs:143:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+cargo/0.49.0/src/cargo/core/profiles.rs:286:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/profiles.rs:294:40 clippy::if_not_else "unnecessary boolean `not` operation"
+cargo/0.49.0/src/cargo/core/profiles.rs:30:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/profiles.rs:342:25 clippy::shadow_unrelated "`maker` is being shadowed"
+cargo/0.49.0/src/cargo/core/profiles.rs:370:41 clippy::unused_self "unused `self` argument"
+cargo/0.49.0/src/cargo/core/profiles.rs:370:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/profiles.rs:372:9 clippy::field_reassign_with_default "field assignment outside of initializer for an instance created with Default::default()"
+cargo/0.49.0/src/cargo/core/profiles.rs:382:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/profiles.rs:383:28 clippy::if_not_else "unnecessary boolean `not` operation"
+cargo/0.49.0/src/cargo/core/profiles.rs:397:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/profiles.rs:405:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/profiles.rs:607:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+cargo/0.49.0/src/cargo/core/profiles.rs:909:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/profiles.rs:923:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/profiles.rs:934:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/profiles.rs:987:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/registry.rs:111:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/registry.rs:127:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/registry.rs:168:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/registry.rs:19:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/registry.rs:240:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/registry.rs:26:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/registry.rs:344:49 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/registry.rs:369:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/registry.rs:424:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/registry.rs:49:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo/0.49.0/src/cargo/core/registry.rs:520:17 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/registry.rs:763:53 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/registry.rs:765:53 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/registry.rs:807:14 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/registry.rs:814:53 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/resolver/conflict_cache.rs:197:29 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/resolver/conflict_cache.rs:41:38 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
+cargo/0.49.0/src/cargo/core/resolver/context.rs:274:53 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/resolver/context.rs:297:9 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/core/resolver/context.rs:42:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/core/resolver/context.rs:74:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/resolver/encode.rs:156:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/resolver/encode.rs:156:5 clippy::too_many_lines "this function has too many lines (164/100)"
+cargo/0.49.0/src/cargo/core/resolver/encode.rs:339:17 clippy::match_wildcard_for_single_variants "wildcard match will miss any future added variants"
+cargo/0.49.0/src/cargo/core/resolver/encode.rs:438:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/core/resolver/encode.rs:449:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/core/resolver/encode.rs:529:34 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/resolver/encode.rs:602:59 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/resolver/encode.rs:623:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/core/resolver/encode.rs:652:27 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/resolver/encode.rs:674:51 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/resolver/errors.rs:103:22 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/resolver/errors.rs:104:22 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/resolver/errors.rs:206:9 clippy::if_not_else "unnecessary boolean `not` operation"
+cargo/0.49.0/src/cargo/core/resolver/errors.rs:257:45 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/resolver/errors.rs:27:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/resolver/errors.rs:305:17 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
+cargo/0.49.0/src/cargo/core/resolver/errors.rs:70:1 clippy::too_many_lines "this function has too many lines (207/100)"
+cargo/0.49.0/src/cargo/core/resolver/features.rs:104:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/core/resolver/features.rs:111:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/resolver/features.rs:162:56 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/resolver/features.rs:179:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo/0.49.0/src/cargo/core/resolver/features.rs:186:23 clippy::doc_markdown "you should put `RequestedFeatures` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/resolver/features.rs:187:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/resolver/features.rs:199:23 clippy::doc_markdown "you should put `RequestedFeatures` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/resolver/features.rs:200:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/resolver/features.rs:209:9 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/core/resolver/features.rs:221:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/resolver/features.rs:231:21 clippy::doc_markdown "you should put `pkg_id/is_build` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/resolver/features.rs:233:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/resolver/features.rs:247:58 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/resolver/features.rs:278:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/resolver/features.rs:394:27 clippy::doc_markdown "you should put `FeatureValue` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/resolver/features.rs:460:19 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/resolver/features.rs:480:24 clippy::doc_markdown "you should put `FeatureValues` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/resolver/features.rs:496:24 clippy::doc_markdown "you should put `FeatureValues` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/resolver/features.rs:561:28 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/core/resolver/features.rs:58:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo/0.49.0/src/cargo/core/resolver/features.rs:67:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+cargo/0.49.0/src/cargo/core/resolver/mod.rs:1017:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/core/resolver/mod.rs:1045:57 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/resolver/mod.rs:122:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/resolver/mod.rs:142:44 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/resolver/mod.rs:180:1 clippy::too_many_lines "this function has too many lines (225/100)"
+cargo/0.49.0/src/cargo/core/resolver/mod.rs:311:17 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/resolver/mod.rs:421:52 clippy::filter_map_next "called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find_map(..)` instead."
+cargo/0.49.0/src/cargo/core/resolver/mod.rs:437:33 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/core/resolver/mod.rs:457:69 clippy::filter_map_next "called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find_map(..)` instead."
+cargo/0.49.0/src/cargo/core/resolver/mod.rs:470:37 clippy::similar_names "binding's name is too similar to existing binding"
+cargo/0.49.0/src/cargo/core/resolver/mod.rs:480:37 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/core/resolver/mod.rs:607:11 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+cargo/0.49.0/src/cargo/core/resolver/mod.rs:631:21 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/resolver/mod.rs:942:15 clippy::if_not_else "unnecessary boolean `not` operation"
+cargo/0.49.0/src/cargo/core/resolver/mod.rs:988:20 clippy::redundant_else "redundant else block"
+cargo/0.49.0/src/cargo/core/resolver/resolve.rs:120:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/resolver/resolve.rs:132:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/resolver/resolve.rs:199:24 clippy::redundant_else "redundant else block"
+cargo/0.49.0/src/cargo/core/resolver/resolve.rs:235:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/resolver/resolve.rs:239:5 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
+cargo/0.49.0/src/cargo/core/resolver/resolve.rs:255:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/resolver/resolve.rs:259:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/resolver/resolve.rs:263:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/resolver/resolve.rs:269:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/resolver/resolve.rs:273:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/resolver/resolve.rs:274:9 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
+cargo/0.49.0/src/cargo/core/resolver/resolve.rs:280:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/resolver/resolve.rs:284:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/resolver/resolve.rs:288:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/resolver/resolve.rs:292:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/resolver/resolve.rs:296:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/resolver/resolve.rs:300:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/resolver/resolve.rs:315:13 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
+cargo/0.49.0/src/cargo/core/resolver/resolve.rs:354:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/resolver/resolve.rs:362:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/resolver/resolve.rs:60:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/core/resolver/resolve.rs:76:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/resolver/resolve.rs:90:35 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/core/resolver/types.rs:111:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/resolver/types.rs:121:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/resolver/types.rs:141:19 clippy::doc_markdown "you should put `ResolveOpts` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/resolver/types.rs:142:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/resolver/types.rs:149:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/resolver/types.rs:181:9 clippy::map_unwrap_or "called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead"
+cargo/0.49.0/src/cargo/core/resolver/types.rs:187:5 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
+cargo/0.49.0/src/cargo/core/resolver/types.rs:261:5 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
+cargo/0.49.0/src/cargo/core/shell.rs:113:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/shell.rs:130:9 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/shell.rs:148:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/shell.rs:153:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/shell.rs:163:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/shell.rs:18:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/shell.rs:198:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/shell.rs:206:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/shell.rs:214:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/shell.rs:228:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/shell.rs:239:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/shell.rs:250:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/shell.rs:259:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/shell.rs:267:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/shell.rs:26:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/shell.rs:277:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/shell.rs:282:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/shell.rs:314:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/shell.rs:322:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/shell.rs:330:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/shell.rs:98:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/source/mod.rs:103:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/source/mod.rs:247:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/core/source/mod.rs:261:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/source/mod.rs:268:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/source/mod.rs:273:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/source/mod.rs:291:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/source/mod.rs:302:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/source/mod.rs:307:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/source/mod.rs:31:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/source/mod.rs:37:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/source/mod.rs:39:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/source/mod.rs:47:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/source/mod.rs:50:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/source/mod.rs:52:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/source/mod.rs:63:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/source/mod.rs:74:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/source/mod.rs:83:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:107:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:128:50 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:147:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:156:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:162:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:166:19 clippy::doc_markdown "you should put `SourceId` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:167:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:171:19 clippy::doc_markdown "you should put `SourceId` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:172:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:178:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:187:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:18:74 clippy::default_trait_access "calling `std::sync::Mutex::default()` is more clear than this expression"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:195:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:207:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:213:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:217:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:225:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:228:16 clippy::option_if_let_else "use Option::map_or_else instead of an if let/else"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:236:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:241:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:252:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:257:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:262:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:305:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:310:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:318:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:326:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:355:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:393:61 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:394:42 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:395:42 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:397:71 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:397:71 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:398:47 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:398:47 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:399:47 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:399:47 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:401:63 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:401:63 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:401:63 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:402:43 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:402:43 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:402:43 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:403:43 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:403:43 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:403:43 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:406:21 clippy::enum_glob_use "usage of wildcard import for enum variants"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:412:41 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:413:36 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:414:36 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:420:47 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:420:47 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:512:17 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:513:17 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:517:17 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:518:17 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:525:17 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:526:17 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:530:17 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:531:17 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:535:33 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:536:37 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:537:42 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:538:38 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:548:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/core/source/source_id.rs:597:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/summary.rs:103:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/summary.rs:123:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/summary.rs:150:1 clippy::too_many_lines "this function has too many lines (141/100)"
+cargo/0.49.0/src/cargo/core/summary.rs:158:9 clippy::enum_glob_use "usage of wildcard import for enum variants"
+cargo/0.49.0/src/cargo/core/summary.rs:181:21 clippy::if_not_else "unnecessary boolean `not` operation"
+cargo/0.49.0/src/cargo/core/summary.rs:192:28 clippy::redundant_else "redundant else block"
+cargo/0.49.0/src/cargo/core/summary.rs:258:32 clippy::redundant_else "redundant else block"
+cargo/0.49.0/src/cargo/core/summary.rs:281:28 clippy::redundant_else "redundant else block"
+cargo/0.49.0/src/cargo/core/summary.rs:303:28 clippy::redundant_else "redundant else block"
+cargo/0.49.0/src/cargo/core/summary.rs:321:51 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/core/summary.rs:344:5 clippy::doc_markdown "you should put `FeatureValue` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/summary.rs:350:85 clippy::doc_markdown "you should put `FeatureValue` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/summary.rs:36:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/summary.rs:378:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/summary.rs:386:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/summary.rs:387:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+cargo/0.49.0/src/cargo/core/summary.rs:407:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+cargo/0.49.0/src/cargo/core/summary.rs:69:34 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/summary.rs:75:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/summary.rs:78:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/summary.rs:81:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/summary.rs:84:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/summary.rs:87:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/summary.rs:90:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/summary.rs:93:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/summary.rs:96:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/summary.rs:99:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/workspace.rs:1019:59 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/core/workspace.rs:1056:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+cargo/0.49.0/src/cargo/core/workspace.rs:113:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/core/workspace.rs:1157:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/core/workspace.rs:128:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/core/workspace.rs:150:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/workspace.rs:159:16 clippy::redundant_else "redundant else block"
+cargo/0.49.0/src/cargo/core/workspace.rs:197:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/workspace.rs:225:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/workspace.rs:255:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/workspace.rs:267:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/workspace.rs:329:37 clippy::doc_markdown "you should put `VirtualManifest` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/workspace.rs:410:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/workspace.rs:440:9 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+cargo/0.49.0/src/cargo/core/workspace.rs:511:32 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/workspace.rs:561:25 clippy::non_ascii_literal "literal non-ASCII character detected"
+cargo/0.49.0/src/cargo/core/workspace.rs:613:13 clippy::filter_map "called `filter_map(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/core/workspace.rs:615:22 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/core/workspace.rs:688:35 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/core/workspace.rs:762:27 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/workspace.rs:784:17 clippy::if_not_else "unnecessary boolean `not` operation"
+cargo/0.49.0/src/cargo/core/workspace.rs:849:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/workspace.rs:893:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/workspace.rs:906:24 clippy::redundant_else "redundant else block"
+cargo/0.49.0/src/cargo/core/workspace.rs:932:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/lib.rs:177:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/lib.rs:180:36 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/lib.rs:180:36 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/lib.rs:180:36 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/lib.rs:180:36 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/lib.rs:180:36 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/lib.rs:1:null clippy::cargo_common_metadata "package `cargo` is missing `package.categories` metadata"
+cargo/0.49.0/src/cargo/lib.rs:1:null clippy::cargo_common_metadata "package `cargo` is missing `package.keywords` metadata"
+cargo/0.49.0/src/cargo/lib.rs:1:null clippy::multiple_crate_versions "multiple versions for dependency `crossbeam-utils`: 0.6.6, 0.7.2"
+cargo/0.49.0/src/cargo/lib.rs:1:null clippy::multiple_crate_versions "multiple versions for dependency `hex`: 0.3.2, 0.4.0"
+cargo/0.49.0/src/cargo/lib.rs:1:null clippy::multiple_crate_versions "multiple versions for dependency `humantime`: 1.3.0, 2.0.0"
+cargo/0.49.0/src/cargo/ops/cargo_clean.rs:205:23 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/ops/cargo_clean.rs:27:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/cargo_clean.rs:27:1 clippy::too_many_lines "this function has too many lines (120/100)"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:1078:14 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:109:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:119:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:1227:17 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:127:35 clippy::from_iter_instead_of_collect "usage of `FromIterator::from_iter`"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:128:32 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:173:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:205:36 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:242:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:249:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:258:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:275:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:275:1 clippy::too_many_lines "this function has too many lines (219/100)"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:468:9 clippy::default_trait_access "calling `std::collections::HashMap::default()` is more clear than this expression"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:548:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:556:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:574:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:583:21 clippy::doc_markdown "you should put `CompileFilter` between ticks in the documentation"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:584:5 clippy::fn_params_excessive_bools "more than 3 bools in function parameters"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:584:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:592:9 clippy::similar_names "binding's name is too similar to existing binding"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:593:9 clippy::similar_names "binding's name is too similar to existing binding"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:607:13 clippy::similar_names "binding's name is too similar to existing binding"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:612:21 clippy::doc_markdown "you should put `CompileFilter` between ticks in the documentation"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:613:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:618:9 clippy::similar_names "binding's name is too similar to existing binding"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:641:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:652:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:655:50 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:673:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:692:49 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:703:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:729:1 clippy::too_many_lines "this function has too many lines (205/100)"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:82:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:874:69 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/ops/cargo_doc.rs:20:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/cargo_fetch.rs:15:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/cargo_fetch.rs:27:46 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/ops/cargo_fetch.rs:36:20 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/ops/cargo_generate_lockfile.rs:160:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/ops/cargo_generate_lockfile.rs:175:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/ops/cargo_generate_lockfile.rs:22:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/cargo_generate_lockfile.rs:37:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/cargo_generate_lockfile.rs:37:1 clippy::too_many_lines "this function has too many lines (171/100)"
+cargo/0.49.0/src/cargo/ops/cargo_install.rs:13:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/cargo/ops/cargo_install.rs:148:1 clippy::fn_params_excessive_bools "more than 3 bools in function parameters"
+cargo/0.49.0/src/cargo/ops/cargo_install.rs:148:1 clippy::too_many_lines "this function has too many lines (316/100)"
+cargo/0.49.0/src/cargo/ops/cargo_install.rs:202:17 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/ops/cargo_install.rs:312:64 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/ops/cargo_install.rs:318:63 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/ops/cargo_install.rs:32:13 clippy::let_underscore_drop "non-binding `let` on a type that implements `Drop`"
+cargo/0.49.0/src/cargo/ops/cargo_install.rs:37:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/cargo_install.rs:454:22 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/ops/cargo_install.rs:483:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/ops/cargo_install.rs:683:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/cargo_new.rs:101:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/cargo_new.rs:245:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/ops/cargo_new.rs:251:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/ops/cargo_new.rs:367:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/cargo_new.rs:405:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/cargo_new.rs:489:5 clippy::doc_markdown "you should put `IgnoreList` between ticks in the documentation"
+cargo/0.49.0/src/cargo/ops/cargo_new.rs:525:47 clippy::doc_markdown "you should put `IgnoreList` between ticks in the documentation"
+cargo/0.49.0/src/cargo/ops/cargo_new.rs:525:9 clippy::doc_markdown "you should put `format_existing` between ticks in the documentation"
+cargo/0.49.0/src/cargo/ops/cargo_new.rs:572:34 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/ops/cargo_new.rs:623:1 clippy::too_many_lines "this function has too many lines (130/100)"
+cargo/0.49.0/src/cargo/ops/cargo_new.rs:781:5 clippy::filter_map_next "called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find_map(..)` instead."
+cargo/0.49.0/src/cargo/ops/cargo_new.rs:800:16 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/ops/cargo_output_metadata.rs:163:36 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/ops/cargo_output_metadata.rs:27:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/cargo_output_metadata.rs:45:45 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/ops/cargo_package.rs:144:1 clippy::too_many_lines "this function has too many lines (112/100)"
+cargo/0.49.0/src/cargo/ops/cargo_package.rs:207:13 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/ops/cargo_package.rs:25:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+cargo/0.49.0/src/cargo/ops/cargo_package.rs:307:54 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/ops/cargo_package.rs:394:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/ops/cargo_package.rs:418:21 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/ops/cargo_package.rs:425:61 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/ops/cargo_package.rs:459:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/ops/cargo_package.rs:66:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/cargo_package.rs:769:29 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/ops/cargo_package.rs:93:20 clippy::if_not_else "unnecessary boolean `not` operation"
+cargo/0.49.0/src/cargo/ops/cargo_pkgid.rs:5:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/cargo_read_manifest.rs:14:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/cargo_read_manifest.rs:171:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/ops/cargo_read_manifest.rs:37:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/cargo_read_manifest.rs:57:49 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/ops/cargo_read_manifest.rs:69:37 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/ops/cargo_run.rs:25:24 clippy::if_not_else "unnecessary boolean `not` operation"
+cargo/0.49.0/src/cargo/ops/cargo_run.rs:35:9 clippy::if_not_else "unnecessary boolean `not` operation"
+cargo/0.49.0/src/cargo/ops/cargo_run.rs:37:16 clippy::redundant_else "redundant else block"
+cargo/0.49.0/src/cargo/ops/cargo_run.rs:53:9 clippy::if_not_else "unnecessary boolean `not` operation"
+cargo/0.49.0/src/cargo/ops/cargo_run.rs:65:16 clippy::redundant_else "redundant else block"
+cargo/0.49.0/src/cargo/ops/cargo_run.rs:9:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/cargo_test.rs:16:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/cargo_test.rs:43:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/cargo_test.rs:84:17 clippy::similar_names "binding's name is too similar to existing binding"
+cargo/0.49.0/src/cargo/ops/cargo_uninstall.rs:14:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/cargo_uninstall.rs:7:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:147:9 clippy::doc_markdown "you should put `PackageId` between ticks in the documentation"
+cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:233:21 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
+cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:244:22 clippy::doc_markdown "you should put `PackageId` between ticks in the documentation"
+cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:244:63 clippy::doc_markdown "you should put `PackageId` between ticks in the documentation"
+cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:253:17 clippy::if_not_else "unnecessary boolean `not` operation"
+cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:370:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:392:9 clippy::find_map "called `find(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:505:8 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
+cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:525:10 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:542:27 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:542:5 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:561:20 clippy::redundant_else "redundant else block"
+cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:613:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:645:41 clippy::doc_markdown "you should put `BTreeSet` between ticks in the documentation"
+cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:654:42 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:662:14 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:674:17 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:681:17 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:92:19 clippy::doc_markdown "you should put `InstallTracker` between ticks in the documentation"
+cargo/0.49.0/src/cargo/ops/fix.rs:200:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/fix.rs:200:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/ops/fix.rs:424:20 clippy::map_unwrap_or "called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead"
+cargo/0.49.0/src/cargo/ops/fix.rs:455:13 clippy::similar_names "binding's name is too similar to existing binding"
+cargo/0.49.0/src/cargo/ops/fix.rs:506:17 clippy::similar_names "binding's name is too similar to existing binding"
+cargo/0.49.0/src/cargo/ops/fix.rs:608:9 clippy::field_reassign_with_default "field assignment outside of initializer for an instance created with Default::default()"
+cargo/0.49.0/src/cargo/ops/fix.rs:612:42 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/ops/fix.rs:619:48 clippy::manual_strip "stripping a prefix manually"
+cargo/0.49.0/src/cargo/ops/fix.rs:66:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/ops/fix.rs:66:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+cargo/0.49.0/src/cargo/ops/fix.rs:708:18 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/ops/fix.rs:77:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/lockfile.rs:154:13 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
+cargo/0.49.0/src/cargo/ops/lockfile.rs:217:9 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
+cargo/0.49.0/src/cargo/ops/lockfile.rs:30:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/lockfile.rs:35:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/lockfile.rs:35:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo/0.49.0/src/cargo/ops/lockfile.rs:87:1 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+cargo/0.49.0/src/cargo/ops/lockfile.rs:8:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/lockfile.rs:8:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo/0.49.0/src/cargo/ops/registry.rs:150:21 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/ops/registry.rs:188:1 clippy::too_many_lines "this function has too many lines (130/100)"
+cargo/0.49.0/src/cargo/ops/registry.rs:196:16 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/ops/registry.rs:212:32 clippy::if_not_else "unnecessary `!=` operation"
+cargo/0.49.0/src/cargo/ops/registry.rs:222:53 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/ops/registry.rs:224:44 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/ops/registry.rs:31:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/ops/registry.rs:346:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/registry.rs:346:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/ops/registry.rs:351:26 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/ops/registry.rs:385:12 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+cargo/0.49.0/src/cargo/ops/registry.rs:386:15 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+cargo/0.49.0/src/cargo/ops/registry.rs:38:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+cargo/0.49.0/src/cargo/ops/registry.rs:477:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/registry.rs:483:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/registry.rs:503:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/registry.rs:505:38 clippy::default_trait_access "calling `util::config::CargoHttpConfig::default()` is more clear than this expression"
+cargo/0.49.0/src/cargo/ops/registry.rs:510:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/registry.rs:529:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/ops/registry.rs:53:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/registry.rs:573:22 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/ops/registry.rs:608:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/registry.rs:621:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/registry.rs:671:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/registry.rs:671:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/ops/registry.rs:674:10 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+cargo/0.49.0/src/cargo/ops/registry.rs:678:17 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/ops/registry.rs:730:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/registry.rs:731:16 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/ops/registry.rs:785:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/registry.rs:794:16 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/ops/registry.rs:828:14 clippy::doc_markdown "you should put `SourceId` between ticks in the documentation"
+cargo/0.49.0/src/cargo/ops/registry.rs:848:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/resolve.rs:199:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/resolve.rs:199:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/ops/resolve.rs:199:1 clippy::too_many_lines "this function has too many lines (137/100)"
+cargo/0.49.0/src/cargo/ops/resolve.rs:241:28 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/ops/resolve.rs:28:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo/0.49.0/src/cargo/ops/resolve.rs:384:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/resolve.rs:417:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/resolve.rs:589:9 clippy::shadow_unrelated "`keep` is being shadowed"
+cargo/0.49.0/src/cargo/ops/resolve.rs:58:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/resolve.rs:58:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/ops/resolve.rs:602:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/ops/resolve.rs:75:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/resolve.rs:75:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/ops/tree/graph.rs:129:26 clippy::doc_markdown "you should put `PackageIds` between ticks in the documentation"
+cargo/0.49.0/src/cargo/ops/tree/graph.rs:131:47 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/ops/tree/graph.rs:152:15 clippy::match_on_vec_items "indexing into a vector may panic"
+cargo/0.49.0/src/cargo/ops/tree/graph.rs:173:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/ops/tree/graph.rs:234:46 clippy::filter_map "called `filter(..).flat_map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/ops/tree/graph.rs:328:44 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/ops/tree/graph.rs:330:50 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/ops/tree/graph.rs:563:35 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/ops/tree/mod.rs:112:11 clippy::non_ascii_literal "literal non-ASCII character detected"
+cargo/0.49.0/src/cargo/ops/tree/mod.rs:113:10 clippy::non_ascii_literal "literal non-ASCII character detected"
+cargo/0.49.0/src/cargo/ops/tree/mod.rs:114:10 clippy::non_ascii_literal "literal non-ASCII character detected"
+cargo/0.49.0/src/cargo/ops/tree/mod.rs:115:12 clippy::non_ascii_literal "literal non-ASCII character detected"
+cargo/0.49.0/src/cargo/ops/tree/mod.rs:126:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/tree/mod.rs:21:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/ops/tree/mod.rs:21:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+cargo/0.49.0/src/cargo/ops/tree/mod.rs:360:30 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/ops/tree/mod.rs:58:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/ops/vendor.rs:14:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/ops/vendor.rs:21:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/vendor.rs:314:34 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/ops/vendor.rs:324:13 clippy::match_wildcard_for_single_variants "wildcard match will miss any future added variants"
+cargo/0.49.0/src/cargo/ops/vendor.rs:70:1 clippy::too_many_lines "this function has too many lines (175/100)"
+cargo/0.49.0/src/cargo/sources/config.rs:102:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/sources/config.rs:135:67 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/sources/config.rs:206:36 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+cargo/0.49.0/src/cargo/sources/config.rs:282:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/sources/config.rs:70:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/sources/config.rs:81:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/sources/config.rs:97:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/sources/directory.rs:14:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/sources/directory.rs:90:56 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/sources/git/source.rs:14:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo/0.49.0/src/cargo/sources/git/source.rs:25:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/sources/git/source.rs:49:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/sources/git/source.rs:53:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/sources/git/source.rs:69:20 clippy::comparison_to_empty "comparison to empty slice"
+cargo/0.49.0/src/cargo/sources/git/utils.rs:1025:19 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/sources/git/utils.rs:1158:9 clippy::manual_strip "stripping a suffix manually"
+cargo/0.49.0/src/cargo/sources/git/utils.rs:176:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/sources/git/utils.rs:180:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/sources/git/utils.rs:184:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/sources/git/utils.rs:188:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/sources/git/utils.rs:242:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/sources/git/utils.rs:253:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/sources/git/utils.rs:262:13 clippy::if_not_else "unnecessary boolean `not` operation"
+cargo/0.49.0/src/cargo/sources/git/utils.rs:289:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/sources/git/utils.rs:294:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/sources/git/utils.rs:298:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/sources/git/utils.rs:308:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/sources/git/utils.rs:472:9 clippy::let_underscore_drop "non-binding `let` on a type that implements `Drop`"
+cargo/0.49.0/src/cargo/sources/git/utils.rs:489:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/sources/git/utils.rs:503:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/sources/git/utils.rs:528:28 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/sources/git/utils.rs:537:21 clippy::let_underscore_drop "non-binding `let` on a type that implements `Drop`"
+cargo/0.49.0/src/cargo/sources/git/utils.rs:588:1 clippy::too_many_lines "this function has too many lines (135/100)"
+cargo/0.49.0/src/cargo/sources/git/utils.rs:758:9 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
+cargo/0.49.0/src/cargo/sources/git/utils.rs:858:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/sources/path.rs:129:44 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/sources/path.rs:143:44 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/sources/path.rs:15:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/sources/path.rs:282:50 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/sources/path.rs:313:21 clippy::similar_names "binding's name is too similar to existing binding"
+cargo/0.49.0/src/cargo/sources/path.rs:314:21 clippy::similar_names "binding's name is too similar to existing binding"
+cargo/0.49.0/src/cargo/sources/path.rs:319:21 clippy::similar_names "binding's name is too similar to existing binding"
+cargo/0.49.0/src/cargo/sources/path.rs:339:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/sources/path.rs:339:9 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+cargo/0.49.0/src/cargo/sources/path.rs:380:9 clippy::unused_self "unused `self` argument"
+cargo/0.49.0/src/cargo/sources/path.rs:419:50 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/sources/path.rs:429:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/sources/path.rs:460:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/sources/path.rs:473:43 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/sources/path.rs:482:43 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/sources/path.rs:63:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/sources/path.rs:77:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/sources/path.rs:98:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/sources/registry/index.rs:117:23 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo/0.49.0/src/cargo/sources/registry/index.rs:121:70 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo/0.49.0/src/cargo/sources/registry/index.rs:167:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo/0.49.0/src/cargo/sources/registry/index.rs:215:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/sources/registry/index.rs:324:23 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/sources/registry/index.rs:393:25 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/sources/registry/index.rs:468:40 clippy::doc_markdown "you should put `SourceId` between ticks in the documentation"
+cargo/0.49.0/src/cargo/sources/registry/index.rs:590:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/sources/registry/index.rs:648:17 clippy::similar_names "binding's name is too similar to existing binding"
+cargo/0.49.0/src/cargo/sources/registry/index.rs:736:1 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
+cargo/0.49.0/src/cargo/sources/registry/index.rs:95:37 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+cargo/0.49.0/src/cargo/sources/registry/local.rs:12:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/sources/registry/mod.rs:192:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/sources/registry/mod.rs:203:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/sources/registry/mod.rs:229:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/sources/registry/mod.rs:372:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/sources/registry/mod.rs:373:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/sources/registry/mod.rs:375:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/sources/registry/mod.rs:381:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/sources/registry/mod.rs:382:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/sources/registry/mod.rs:383:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/sources/registry/mod.rs:384:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/sources/registry/mod.rs:452:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/sources/registry/mod.rs:582:20 clippy::redundant_else "redundant else block"
+cargo/0.49.0/src/cargo/sources/registry/mod.rs:621:9 clippy::if_not_else "unnecessary `!=` operation"
+cargo/0.49.0/src/cargo/sources/registry/remote.rs:139:17 clippy::unused_self "unused `self` argument"
+cargo/0.49.0/src/cargo/sources/registry/remote.rs:32:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/sources/registry/remote.rs:72:13 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/sources/replaced.rs:12:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/sources/replaced.rs:5:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/util/canonical_url.rs:19:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/canonical_url.rs:65:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/command_prelude.rs:218:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/command_prelude.rs:222:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/command_prelude.rs:234:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/command_prelude.rs:249:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/command_prelude.rs:264:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/command_prelude.rs:279:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/command_prelude.rs:298:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/command_prelude.rs:320:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/command_prelude.rs:328:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/command_prelude.rs:352:13 clippy::if_not_else "unnecessary boolean `not` operation"
+cargo/0.49.0/src/cargo/util/command_prelude.rs:363:13 clippy::if_not_else "unnecessary boolean `not` operation"
+cargo/0.49.0/src/cargo/util/command_prelude.rs:378:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/command_prelude.rs:387:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/command_prelude.rs:387:5 clippy::too_many_lines "this function has too many lines (104/100)"
+cargo/0.49.0/src/cargo/util/command_prelude.rs:39:20 clippy::doc_markdown "you should put `arg_package_spec` between ticks in the documentation"
+cargo/0.49.0/src/cargo/util/command_prelude.rs:504:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/command_prelude.rs:516:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/command_prelude.rs:530:40 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/util/command_prelude.rs:531:43 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/util/command_prelude.rs:536:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/command_prelude.rs:556:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/command_prelude.rs:575:49 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/util/command_prelude.rs:580:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/command_prelude.rs:631:18 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/util/command_prelude.rs:638:18 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/util/command_prelude.rs:647:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/command_prelude.rs:651:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/command_prelude.rs:662:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/command_prelude.rs:665:51 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/util/config/de.rs:420:16 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+cargo/0.49.0/src/cargo/util/config/de.rs:46:25 clippy::doc_markdown "you should put `CV::List` between ticks in the documentation"
+cargo/0.49.0/src/cargo/util/config/de.rs:47:24 clippy::doc_markdown "you should put `ConfigSeqAccess` between ticks in the documentation"
+cargo/0.49.0/src/cargo/util/config/de.rs:527:53 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo/0.49.0/src/cargo/util/config/de.rs:530:53 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo/0.49.0/src/cargo/util/config/de.rs:532:68 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo/0.49.0/src/cargo/util/config/key.rs:11:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo/0.49.0/src/cargo/util/config/key.rs:69:9 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
+cargo/0.49.0/src/cargo/util/config/mod.rs:100:71 clippy::doc_markdown "you should put `OptValue` between ticks in the documentation"
+cargo/0.49.0/src/cargo/util/config/mod.rs:100:71 clippy::doc_markdown "you should put `OptValue` between ticks in the documentation"
+cargo/0.49.0/src/cargo/util/config/mod.rs:100:71 clippy::doc_markdown "you should put `OptValue` between ticks in the documentation"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1049:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1064:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1090:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1166:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1179:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1184:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1189:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1203:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1211:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1216:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1225:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1229:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:124:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1254:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1279:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1281:9 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1323:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1339:39 clippy::unused_self "unused `self` argument"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1344:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1420:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1553:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1560:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1567:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1574:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1581:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1588:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1598:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1619:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1623:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1623:64 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1649:9 clippy::option_if_let_else "use Option::map_or_else instead of an if let/else"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1699:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1730:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1757:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1770:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1778:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1804:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1896:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1901:5 clippy::doc_markdown "you should put `StringList` between ticks in the documentation"
+cargo/0.49.0/src/cargo/util/config/mod.rs:214:13 clippy::match_wildcard_for_single_variants "wildcard match will miss any future added variants"
+cargo/0.49.0/src/cargo/util/config/mod.rs:259:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:298:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:311:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:318:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:353:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:401:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:411:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:419:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:431:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:449:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:454:16 clippy::option_if_let_else "use Option::map_or instead of an if let/else"
+cargo/0.49.0/src/cargo/util/config/mod.rs:547:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:556:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:582:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:595:20 clippy::doc_markdown "you should put `StringList` between ticks in the documentation"
+cargo/0.49.0/src/cargo/util/config/mod.rs:689:20 clippy::unused_self "unused `self` argument"
+cargo/0.49.0/src/cargo/util/config/mod.rs:699:5 clippy::fn_params_excessive_bools "more than 3 bools in function parameters"
+cargo/0.49.0/src/cargo/util/config/mod.rs:699:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:719:58 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/util/config/mod.rs:816:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:875:36 clippy::similar_names "binding's name is too similar to existing binding"
+cargo/0.49.0/src/cargo/util/config/mod.rs:876:37 clippy::similar_names "binding's name is too similar to existing binding"
+cargo/0.49.0/src/cargo/util/config/path.rs:10:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo/0.49.0/src/cargo/util/config/path.rs:14:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/config/path.rs:48:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/util/config/target.rs:12:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/util/config/target.rs:24:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/util/config/value.rs:29:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo/0.49.0/src/cargo/util/config/value.rs:80:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/config/value.rs:81:9 clippy::match_like_matches_macro "match expression looks like `matches!` macro"
+cargo/0.49.0/src/cargo/util/cpu.rs:11:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/cpu.rs:22:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/cpu.rs:82:25 clippy::cast_precision_loss "casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+cargo/0.49.0/src/cargo/util/cpu.rs:82:9 clippy::cast_precision_loss "casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+cargo/0.49.0/src/cargo/util/dependency_queue.rs:109:27 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/util/dependency_queue.rs:136:20 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/util/dependency_queue.rs:151:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/dependency_queue.rs:156:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/dependency_queue.rs:46:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/dependency_queue.rs:91:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/util/diagnostic_server.rs:218:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo/0.49.0/src/cargo/util/diagnostic_server.rs:230:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/diagnostic_server.rs:242:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/diagnostic_server.rs:58:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/diagnostic_server.rs:96:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/diagnostic_server.rs:96:5 clippy::too_many_lines "this function has too many lines (110/100)"
+cargo/0.49.0/src/cargo/util/diagnostic_server.rs:99:21 clippy::shadow_unrelated "`msg` is being shadowed"
+cargo/0.49.0/src/cargo/util/errors.rs:101:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/errors.rs:143:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/errors.rs:150:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/errors.rs:15:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/errors.rs:237:5 clippy::pub_enum_variant_names "variant name ends with the enum's name"
+cargo/0.49.0/src/cargo/util/errors.rs:245:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/errors.rs:321:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/errors.rs:328:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/errors.rs:356:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/errors.rs:391:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/util/errors.rs:392:13 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/cargo/util/errors.rs:465:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/errors.rs:473:5 clippy::manual_range_contains "manual `RangeInclusive::contains` implementation"
+cargo/0.49.0/src/cargo/util/errors.rs:66:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/flock.rs:115:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/flock.rs:11:5 clippy::wildcard_imports "usage of wildcard import"
+cargo/0.49.0/src/cargo/util/flock.rs:134:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/flock.rs:142:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/flock.rs:150:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/flock.rs:156:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/flock.rs:170:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/flock.rs:192:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/flock.rs:29:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/flock.rs:321:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/util/flock.rs:335:23 clippy::cast_possible_truncation "casting `i64` to `u32` may truncate the value"
+cargo/0.49.0/src/cargo/util/flock.rs:335:23 clippy::cast_sign_loss "casting `i64` to `u32` may lose the sign of the value"
+cargo/0.49.0/src/cargo/util/flock.rs:335:44 clippy::cast_possible_truncation "casting `i64` to `u32` may truncate the value"
+cargo/0.49.0/src/cargo/util/flock.rs:379:35 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/util/flock.rs:37:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/flock.rs:43:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/flock.rs:52:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/graph.rs:10:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/graph.rs:115:13 clippy::find_map "called `find(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/util/graph.rs:41:51 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/util/graph.rs:45:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/graph.rs:95:13 clippy::find_map "called `find(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/util/hasher.rs:12:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/hasher.rs:9:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo/0.49.0/src/cargo/util/hex.rs:10:9 clippy::cast_possible_truncation "casting `u64` to `u8` may truncate the value"
+cargo/0.49.0/src/cargo/util/hex.rs:11:9 clippy::cast_possible_truncation "casting `u64` to `u8` may truncate the value"
+cargo/0.49.0/src/cargo/util/hex.rs:12:9 clippy::cast_possible_truncation "casting `u64` to `u8` may truncate the value"
+cargo/0.49.0/src/cargo/util/hex.rs:13:9 clippy::cast_possible_truncation "casting `u64` to `u8` may truncate the value"
+cargo/0.49.0/src/cargo/util/hex.rs:14:9 clippy::cast_possible_truncation "casting `u64` to `u8` may truncate the value"
+cargo/0.49.0/src/cargo/util/hex.rs:15:9 clippy::cast_possible_truncation "casting `u64` to `u8` may truncate the value"
+cargo/0.49.0/src/cargo/util/hex.rs:25:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/hex.rs:6:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo/0.49.0/src/cargo/util/hex.rs:6:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/hex.rs:8:9 clippy::cast_possible_truncation "casting `u64` to `u8` may truncate the value"
+cargo/0.49.0/src/cargo/util/hex.rs:9:9 clippy::cast_possible_truncation "casting `u64` to `u8` may truncate the value"
+cargo/0.49.0/src/cargo/util/important_paths.rs:23:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/important_paths.rs:6:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/interning.rs:66:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/interning.rs:77:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/into_url.rs:10:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/into_url_with_base.rs:9:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/job.rs:20:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/lev_distance.rs:3:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/lockserver.rs:111:32 clippy::redundant_else "redundant else block"
+cargo/0.49.0/src/cargo/util/lockserver.rs:158:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/lockserver.rs:46:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/lockserver.rs:58:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/lockserver.rs:62:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/mod.rs:68:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/mod.rs:79:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/network.rs:12:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/network.rs:19:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/network.rs:84:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/paths.rs:109:12 clippy::redundant_else "redundant else block"
+cargo/0.49.0/src/cargo/util/paths.rs:114:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/paths.rs:121:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/paths.rs:125:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/paths.rs:130:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/paths.rs:14:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/paths.rs:14:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo/0.49.0/src/cargo/util/paths.rs:151:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/paths.rs:167:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/paths.rs:173:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/paths.rs:178:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/paths.rs:185:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/paths.rs:199:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/paths.rs:215:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/paths.rs:228:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/paths.rs:251:9 clippy::option_if_let_else "use Option::map_or instead of an if let/else"
+cargo/0.49.0/src/cargo/util/paths.rs:267:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/paths.rs:276:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/paths.rs:29:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/paths.rs:303:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/paths.rs:312:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/paths.rs:346:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/paths.rs:415:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/paths.rs:445:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/paths.rs:459:45 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/util/paths.rs:469:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/paths.rs:54:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/paths.rs:61:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/paths.rs:63:19 clippy::option_if_let_else "use Option::map_or_else instead of an if let/else"
+cargo/0.49.0/src/cargo/util/paths.rs:88:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/paths.rs:93:31 clippy::comparison_to_empty "comparison to empty slice"
+cargo/0.49.0/src/cargo/util/process_builder.rs:106:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/process_builder.rs:111:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/process_builder.rs:122:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/process_builder.rs:132:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/process_builder.rs:152:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/process_builder.rs:185:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/process_builder.rs:190:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/process_builder.rs:218:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/process_builder.rs:307:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/process_builder.rs:343:39 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+cargo/0.49.0/src/cargo/util/progress.rs:122:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/progress.rs:136:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/progress.rs:15:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/util/progress.rs:249:19 clippy::cast_precision_loss "casting `usize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`usize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+cargo/0.49.0/src/cargo/util/progress.rs:249:34 clippy::cast_precision_loss "casting `usize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`usize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+cargo/0.49.0/src/cargo/util/progress.rs:250:19 clippy::if_not_else "unnecessary boolean `not` operation"
+cargo/0.49.0/src/cargo/util/progress.rs:263:22 clippy::cast_precision_loss "casting `usize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`usize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+cargo/0.49.0/src/cargo/util/progress.rs:264:22 clippy::cast_possible_truncation "casting `f64` to `usize` may truncate the value"
+cargo/0.49.0/src/cargo/util/progress.rs:264:22 clippy::cast_sign_loss "casting `f64` to `usize` may lose the sign of the value"
+cargo/0.49.0/src/cargo/util/progress.rs:269:17 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
+cargo/0.49.0/src/cargo/util/progress.rs:272:17 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
+cargo/0.49.0/src/cargo/util/progress.rs:274:17 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
+cargo/0.49.0/src/cargo/util/progress.rs:280:13 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
+cargo/0.49.0/src/cargo/util/progress.rs:282:9 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
+cargo/0.49.0/src/cargo/util/progress.rs:89:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/progress.rs:97:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/queue.rs:25:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/read2.rs:11:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/read2.rs:31:17 clippy::similar_names "binding's name is too similar to existing binding"
+cargo/0.49.0/src/cargo/util/restricted_names.rs:13:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/restricted_names.rs:26:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/restricted_names.rs:35:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/restricted_names.rs:45:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/restricted_names.rs:87:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/restricted_names.rs:89:21 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/util/restricted_names.rs:8:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/rustc.rs:103:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/rustc.rs:114:5 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
+cargo/0.49.0/src/cargo/util/rustc.rs:115:5 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
+cargo/0.49.0/src/cargo/util/rustc.rs:162:17 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/util/rustc.rs:39:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/rustc.rs:55:13 clippy::find_map "called `find(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/util/sha256.rs:10:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/sha256.rs:20:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/sha256.rs:31:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/sha256.rs:40:24 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo/0.49.0/src/cargo/util/to_semver.rs:5:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:1005:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:1005:5 clippy::too_many_lines "this function has too many lines (282/100)"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:1094:36 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:1121:13 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:1197:32 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:124:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:1504:9 clippy::unused_self "unused `self` argument"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:1526:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:1582:19 clippy::default_trait_access "calling `util::toml::DetailedTomlDependency::default()` is more clear than this expression"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:1598:5 clippy::too_many_lines "this function has too many lines (153/100)"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:1687:33 clippy::unnecessary_lazy_evaluations "unnecessary closure used to substitute value for `Option::None`"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:178:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:248:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:274:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:277:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:281:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:285:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:294:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:31:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:381:35 clippy::cast_possible_truncation "casting `i64` to `u32` may truncate the value"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:381:35 clippy::cast_sign_loss "casting `i64` to `u32` may lose the sign of the value"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:388:35 clippy::cast_possible_truncation "casting `u64` to `u32` may truncate the value"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:398:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:450:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:536:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:783:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:824:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:834:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:83:42 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:852:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:852:5 clippy::too_many_lines "this function has too many lines (138/100)"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:962:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:971:24 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:979:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:98:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/util/toml/mod.rs:999:23 clippy::default_trait_access "calling `util::toml::DetailedTomlDependency::default()` is more clear than this expression"
+cargo/0.49.0/src/cargo/util/toml/targets.rs:112:27 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/util/toml/targets.rs:325:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/util/toml/targets.rs:586:21 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/util/toml/targets.rs:593:42 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/util/toml/targets.rs:605:19 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/util/toml/targets.rs:612:42 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/util/toml/targets.rs:756:36 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/util/toml/targets.rs:810:24 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
+cargo/0.49.0/src/cargo/util/vcs.rs:10:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo/0.49.0/src/cargo/util/vcs.rs:33:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/vcs.rs:37:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/vcs.rs:43:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/vcs.rs:47:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/vcs.rs:59:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/vcs.rs:66:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/workspace.rs:52:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/workspace.rs:56:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/workspace.rs:60:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/workspace.rs:64:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+iron/0.6.1/src/error.rs:24:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+iron/0.6.1/src/iron.rs:105:13 clippy::redundant_field_names "redundant field names in struct initialization"
+iron/0.6.1/src/iron.rs:119:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+iron/0.6.1/src/iron.rs:133:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+iron/0.6.1/src/iron.rs:143:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+iron/0.6.1/src/iron.rs:149:13 clippy::redundant_field_names "redundant field names in struct initialization"
+iron/0.6.1/src/iron.rs:167:49 clippy::similar_names "binding's name is too similar to existing binding"
+iron/0.6.1/src/iron.rs:80:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+iron/0.6.1/src/iron.rs:85:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+iron/0.6.1/src/iron.rs:90:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+iron/0.6.1/src/lib.rs:1:null clippy::cargo_common_metadata "package `iron` is missing `package.categories` metadata"
+iron/0.6.1/src/lib.rs:1:null clippy::cargo_common_metadata "package `iron` is missing `package.keywords` metadata"
+iron/0.6.1/src/lib.rs:1:null clippy::multiple_crate_versions "multiple versions for dependency `log`: 0.3.9, 0.4.8"
+iron/0.6.1/src/middleware/mod.rs:137:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+iron/0.6.1/src/middleware/mod.rs:150:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+iron/0.6.1/src/middleware/mod.rs:152:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+iron/0.6.1/src/middleware/mod.rs:159:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+iron/0.6.1/src/middleware/mod.rs:171:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+iron/0.6.1/src/middleware/mod.rs:173:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+iron/0.6.1/src/middleware/mod.rs:182:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+iron/0.6.1/src/middleware/mod.rs:192:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+iron/0.6.1/src/middleware/mod.rs:217:25 clippy::doc_markdown "you should put `ChainBuilder` between ticks in the documentation"
+iron/0.6.1/src/middleware/mod.rs:328:20 clippy::similar_names "binding's name is too similar to existing binding"
+iron/0.6.1/src/middleware/mod.rs:360:16 clippy::similar_names "binding's name is too similar to existing binding"
+iron/0.6.1/src/middleware/mod.rs:368:33 clippy::similar_names "binding's name is too similar to existing binding"
+iron/0.6.1/src/middleware/mod.rs:428:40 clippy::similar_names "binding's name is too similar to existing binding"
+iron/0.6.1/src/middleware/mod.rs:434:40 clippy::similar_names "binding's name is too similar to existing binding"
+iron/0.6.1/src/middleware/mod.rs:444:40 clippy::similar_names "binding's name is too similar to existing binding"
+iron/0.6.1/src/modifiers.rs:132:14 clippy::expect_fun_call "use of `expect` followed by a function call"
+iron/0.6.1/src/request/mod.rs:113:24 clippy::similar_names "binding's name is too similar to existing binding"
+iron/0.6.1/src/request/mod.rs:121:13 clippy::redundant_field_names "redundant field names in struct initialization"
+iron/0.6.1/src/request/mod.rs:123:13 clippy::redundant_field_names "redundant field names in struct initialization"
+iron/0.6.1/src/request/mod.rs:124:13 clippy::redundant_field_names "redundant field names in struct initialization"
+iron/0.6.1/src/request/mod.rs:126:13 clippy::redundant_field_names "redundant field names in struct initialization"
+iron/0.6.1/src/request/mod.rs:128:13 clippy::redundant_field_names "redundant field names in struct initialization"
+iron/0.6.1/src/request/mod.rs:153:69 clippy::doc_markdown "you should put `HttpReader` between ticks in the documentation"
+iron/0.6.1/src/request/mod.rs:154:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+iron/0.6.1/src/request/mod.rs:32:1 clippy::manual_non_exhaustive "this seems like a manual implementation of the non-exhaustive pattern"
+iron/0.6.1/src/request/mod.rs:75:34 clippy::doc_markdown "you should put `HttpRequest` between ticks in the documentation"
+iron/0.6.1/src/request/mod.rs:77:39 clippy::doc_markdown "you should put `HttpRequest` between ticks in the documentation"
+iron/0.6.1/src/request/mod.rs:78:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+iron/0.6.1/src/request/mod.rs:82:13 clippy::similar_names "binding's name is too similar to existing binding"
+iron/0.6.1/src/request/mod.rs:83:29 clippy::similar_names "binding's name is too similar to existing binding"
+iron/0.6.1/src/request/mod.rs:85:24 clippy::similar_names "binding's name is too similar to existing binding"
+iron/0.6.1/src/request/url.rs:109:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+iron/0.6.1/src/request/url.rs:117:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+iron/0.6.1/src/request/url.rs:129:1 clippy::from_over_into "an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true"
+iron/0.6.1/src/request/url.rs:21:14 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
+iron/0.6.1/src/request/url.rs:22:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+iron/0.6.1/src/request/url.rs:31:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+iron/0.6.1/src/request/url.rs:47:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+iron/0.6.1/src/request/url.rs:52:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+iron/0.6.1/src/request/url.rs:57:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+iron/0.6.1/src/request/url.rs:63:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+iron/0.6.1/src/request/url.rs:73:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+iron/0.6.1/src/request/url.rs:83:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+iron/0.6.1/src/request/url.rs:96:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+iron/0.6.1/src/response.rs:121:19 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+iron/0.6.1/src/response.rs:125:43 clippy::redundant_closure_for_method_calls "redundant closure found"
+iron/0.6.1/src/response.rs:139:41 clippy::redundant_closure_for_method_calls "redundant closure found"
+iron/0.6.1/src/response.rs:24:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+iron/0.6.1/src/response.rs:95:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+iron/0.6.1/src/response.rs:95:5 clippy::new_without_default "you should consider adding a `Default` implementation for `response::Response`"
+libc/0.2.81/build.rs:114:19 clippy::map_unwrap_or "called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead"
+libc/0.2.81/build.rs:124:5 clippy::question_mark "this block may be rewritten with the `?` operator"
+libc/0.2.81/build.rs:133:5 clippy::question_mark "this block may be rewritten with the `?` operator"
+libc/0.2.81/src/macros.rs:243:17 clippy::missing_safety_doc "unsafe function's docs miss `# Safety` section"
+libc/0.2.81/src/macros.rs:243:17 clippy::missing_safety_doc "unsafe function's docs miss `# Safety` section"
+libc/0.2.81/src/macros.rs:243:17 clippy::missing_safety_doc "unsafe function's docs miss `# Safety` section"
+libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:428:29 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:429:30 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:431:30 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:432:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:433:29 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:434:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:595:33 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:596:33 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:597:35 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:622:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:673:34 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:696:33 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:697:35 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:698:33 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:699:35 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:712:34 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:721:35 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:722:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:723:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:751:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:752:30 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:753:30 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:754:30 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:755:29 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:756:29 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:757:29 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:758:29 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:759:29 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:760:29 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:768:30 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:769:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:771:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:772:29 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:773:29 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:774:29 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:775:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:776:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:777:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:778:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:779:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:780:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:781:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:782:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:783:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:784:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:785:33 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:786:33 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:787:30 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:788:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:789:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:790:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:791:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:792:33 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:794:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:795:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:796:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:797:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:798:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:799:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:800:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:801:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:803:27 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:804:28 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:805:28 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:806:29 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:807:29 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:808:29 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:809:29 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:810:29 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:811:29 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:812:30 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:813:30 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:814:30 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:815:30 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:816:30 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:817:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:818:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:821:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:822:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:823:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:824:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:825:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:826:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:827:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:828:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:829:33 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:830:33 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:831:33 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:832:33 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:833:33 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:834:33 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:835:33 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:836:33 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:841:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:842:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:843:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:844:33 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:1120:38 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:178:34 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:291:5 clippy::missing_safety_doc "unsafe function's docs miss `# Safety` section"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:291:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:302:5 clippy::missing_safety_doc "unsafe function's docs miss `# Safety` section"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:302:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:355:13 clippy::missing_safety_doc "unsafe function's docs miss `# Safety` section"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:355:13 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:359:13 clippy::missing_safety_doc "unsafe function's docs miss `# Safety` section"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:359:13 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:363:13 clippy::missing_safety_doc "unsafe function's docs miss `# Safety` section"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:363:13 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:367:13 clippy::missing_safety_doc "unsafe function's docs miss `# Safety` section"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:367:13 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:371:13 clippy::missing_safety_doc "unsafe function's docs miss `# Safety` section"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:371:13 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:534:36 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:645:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:727:40 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:728:40 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:729:39 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:731:44 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:732:36 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:733:41 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:734:43 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:735:42 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:736:40 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:737:36 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:738:37 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:741:39 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:742:40 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:743:40 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:744:40 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:745:40 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:746:43 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:747:42 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:748:40 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:749:39 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:750:41 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:751:41 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:752:43 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:753:42 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:755:42 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:756:41 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:757:41 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:758:39 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:759:39 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:761:41 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:762:44 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:763:45 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:764:40 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:765:40 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:766:40 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:767:44 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:768:44 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:769:39 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:770:35 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:771:35 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:772:37 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:773:39 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:774:45 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:775:41 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:776:39 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:803:34 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:841:30 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:842:37 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:982:40 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:984:46 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1209:36 clippy::cast_possible_truncation "casting `i32` to `i16` may truncate the value"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1210:36 clippy::cast_possible_truncation "casting `i32` to `i16` may truncate the value"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1235:39 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1236:41 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1274:42 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1324:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1333:37 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1334:35 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1346:34 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1346:34 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1346:34 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1347:37 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1347:37 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1347:37 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1348:36 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1348:36 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1348:36 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1349:37 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1349:37 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1349:37 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1350:35 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1350:35 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1350:35 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1351:36 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1351:36 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1351:36 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1352:31 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1352:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1352:31 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1419:36 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1420:36 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1421:36 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1422:36 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1423:36 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1490:37 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1561:46 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1562:45 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1567:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1568:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1586:26 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1587:34 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1588:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1589:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1897:38 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1898:51 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1900:39 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1969:34 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1970:34 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1971:36 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1972:36 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1973:36 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1974:37 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1975:37 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1976:36 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1977:36 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1978:39 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1979:39 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1980:39 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1981:39 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1982:39 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1983:39 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1984:38 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1985:38 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1986:35 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1987:35 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1988:35 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1989:35 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1990:38 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1991:37 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1992:37 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1993:38 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1994:37 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1995:37 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1996:37 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1997:37 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1998:33 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:1999:33 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2000:33 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2001:34 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2002:34 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2003:34 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2004:35 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2005:35 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2032:30 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2033:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2034:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2035:29 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2036:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2037:28 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2038:27 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2039:29 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2041:29 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2042:28 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2043:27 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2044:34 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2045:27 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2046:33 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2048:28 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2049:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2050:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2051:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2052:26 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2053:36 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2318:42 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2321:38 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2331:39 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2487:42 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2488:42 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2489:43 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2490:43 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2491:43 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2493:47 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2494:44 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2495:46 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2496:47 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2497:49 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2498:48 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2499:50 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2500:45 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2572:9 clippy::needless_return "unneeded `return` statement"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2578:20 clippy::zero_ptr "`0 as *mut _` detected"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2588:13 clippy::zero_ptr "`0 as *mut _` detected"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2596:52 clippy::used_underscore_binding "used binding `_dummy` which is prefixed with an underscore. A leading underscore signals that a binding will not be used."
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2597:11 clippy::cast_sign_loss "casting `i32` to `usize` may lose the sign of the value"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2601:21 clippy::explicit_iter_loop "it is more concise to loop over references to containers instead of using explicit iteration methods"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2611:9 clippy::unused_unit "unneeded unit expression"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2619:9 clippy::unused_unit "unneeded unit expression"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2634:9 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2647:25 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2648:25 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2649:9 clippy::cast_possible_truncation "casting `u64` to `u32` may truncate the value"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2654:18 clippy::identity_op "the operation is ineffective. Consider reducing it to `(dev & 0x00000000000000ff)`"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2654:25 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2655:25 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2656:9 clippy::cast_possible_truncation "casting `u64` to `u32` may truncate the value"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2660:21 clippy::cast_lossless "casting `u32` to `u64` may become silently lossy if you later change the type"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2661:21 clippy::cast_lossless "casting `u32` to `u64` may become silently lossy if you later change the type"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2663:25 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2664:25 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2665:16 clippy::identity_op "the operation is ineffective. Consider reducing it to `(minor & 0x000000ff)`"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2665:25 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2666:25 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:40:1 clippy::empty_enum "enum with no variants"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:954:34 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1000:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1001:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1002:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1016:29 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1017:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1018:33 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1019:33 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1020:33 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1029:29 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1030:29 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1031:30 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1032:29 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1033:29 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1034:29 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1035:29 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1041:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1042:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1043:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1044:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1045:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1046:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1047:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1048:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1049:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1050:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1051:33 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1053:29 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1054:33 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1055:30 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1056:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1057:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1058:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1059:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1060:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1073:42 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1074:43 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1075:37 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1076:37 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1077:41 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1078:35 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1079:35 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1080:36 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1081:35 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1082:35 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1083:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1084:38 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1086:30 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1087:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1089:30 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1090:33 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1091:30 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1094:40 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1095:37 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1096:41 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1097:40 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1098:39 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1099:34 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1100:36 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1101:38 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1102:37 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1105:44 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1106:41 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1107:42 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1108:42 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1109:41 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1110:46 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1111:41 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1112:44 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1113:40 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1114:47 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1115:36 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1126:34 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1127:29 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1128:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1179:32 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1180:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:1218:27 clippy::identity_op "the operation is ineffective. Consider reducing it to `IPOPT_CONTROL`"
+libc/0.2.81/src/unix/linux_like/mod.rs:1314:9 clippy::precedence "operator precedence can trip the unwary"
+libc/0.2.81/src/unix/linux_like/mod.rs:1323:13 clippy::zero_ptr "`0 as *mut _` detected"
+libc/0.2.81/src/unix/linux_like/mod.rs:1332:9 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+libc/0.2.81/src/unix/linux_like/mod.rs:1337:9 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+libc/0.2.81/src/unix/linux_like/mod.rs:1341:18 clippy::cast_sign_loss "casting `i32` to `usize` may lose the sign of the value"
+libc/0.2.81/src/unix/linux_like/mod.rs:1344:9 clippy::needless_return "unneeded `return` statement"
+libc/0.2.81/src/unix/linux_like/mod.rs:1348:18 clippy::cast_sign_loss "casting `i32` to `usize` may lose the sign of the value"
+libc/0.2.81/src/unix/linux_like/mod.rs:1350:9 clippy::needless_return "unneeded `return` statement"
+libc/0.2.81/src/unix/linux_like/mod.rs:1354:18 clippy::cast_sign_loss "casting `i32` to `usize` may lose the sign of the value"
+libc/0.2.81/src/unix/linux_like/mod.rs:1357:9 clippy::needless_return "unneeded `return` statement"
+libc/0.2.81/src/unix/linux_like/mod.rs:1361:21 clippy::explicit_iter_loop "it is more concise to loop over references to containers instead of using explicit iteration methods"
+libc/0.2.81/src/unix/linux_like/mod.rs:1381:9 clippy::cast_possible_truncation "casting `i32` to `i8` may truncate the value"
+libc/0.2.81/src/unix/linux_like/mod.rs:1389:9 clippy::verbose_bit_mask "bit mask could be simplified with a call to `trailing_zeros`"
+libc/0.2.81/src/unix/linux_like/mod.rs:446:31 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:591:36 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:592:38 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:593:35 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:594:33 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:595:34 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:596:36 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:597:37 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:598:37 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:599:39 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:600:34 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:601:35 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:602:35 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:607:37 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:608:35 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:764:35 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:765:39 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:991:30 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/linux_like/mod.rs:9:1 clippy::empty_enum "enum with no variants"
+libc/0.2.81/src/unix/mod.rs:198:29 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/mod.rs:199:28 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/mod.rs:201:35 clippy::unnecessary_cast "casting integer literal to `usize` is unnecessary"
+libc/0.2.81/src/unix/mod.rs:202:35 clippy::unnecessary_cast "casting integer literal to `usize` is unnecessary"
+libc/0.2.81/src/unix/mod.rs:282:40 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/mod.rs:284:41 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/mod.rs:285:36 clippy::unreadable_literal "long literal lacking separators"
+libc/0.2.81/src/unix/mod.rs:34:1 clippy::empty_enum "enum with no variants"
+libc/0.2.81/src/unix/mod.rs:386:1 clippy::empty_enum "enum with no variants"
+libc/0.2.81/src/unix/mod.rs:394:1 clippy::empty_enum "enum with no variants"
+log/0.4.11/src/lib.rs:1047:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log/0.4.11/src/lib.rs:1053:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log/0.4.11/src/lib.rs:1059:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log/0.4.11/src/lib.rs:1093:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log/0.4.11/src/lib.rs:1093:5 clippy::new_without_default "you should consider adding a `Default` implementation for `MetadataBuilder<'a>`"
+log/0.4.11/src/lib.rs:1118:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log/0.4.11/src/lib.rs:1177:1 clippy::inline_always "you have declared `#[inline(always)]` on `max_level`. This is usually a bad idea"
+log/0.4.11/src/lib.rs:1178:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+log/0.4.11/src/lib.rs:1306:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+log/0.4.11/src/lib.rs:1358:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+log/0.4.11/src/lib.rs:1359:5 clippy::if_not_else "unnecessary `!=` operation"
+log/0.4.11/src/lib.rs:1407:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+log/0.4.11/src/lib.rs:329:27 clippy::derive_hash_xor_eq "you are deriving `Hash` but have implemented `PartialEq` explicitly"
+log/0.4.11/src/lib.rs:356:1 clippy::expl_impl_clone_on_copy "you are implementing `Clone` explicitly on a `Copy` type"
+log/0.4.11/src/lib.rs:448:12 clippy::manual_range_contains "manual `RangeInclusive::contains` implementation"
+log/0.4.11/src/lib.rs:468:13 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
+log/0.4.11/src/lib.rs:500:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log/0.4.11/src/lib.rs:506:28 clippy::trivially_copy_pass_by_ref "this argument (8 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+log/0.4.11/src/lib.rs:506:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log/0.4.11/src/lib.rs:520:27 clippy::derive_hash_xor_eq "you are deriving `Hash` but have implemented `PartialEq` explicitly"
+log/0.4.11/src/lib.rs:538:1 clippy::expl_impl_clone_on_copy "you are implementing `Clone` explicitly on a `Copy` type"
+log/0.4.11/src/lib.rs:653:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log/0.4.11/src/lib.rs:661:21 clippy::trivially_copy_pass_by_ref "this argument (8 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+log/0.4.11/src/lib.rs:661:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log/0.4.11/src/lib.rs:677:44 clippy::match_same_arms "this `match` has identical arm bodies"
+log/0.4.11/src/lib.rs:758:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log/0.4.11/src/lib.rs:764:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log/0.4.11/src/lib.rs:770:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log/0.4.11/src/lib.rs:776:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log/0.4.11/src/lib.rs:782:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log/0.4.11/src/lib.rs:788:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log/0.4.11/src/lib.rs:794:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log/0.4.11/src/lib.rs:803:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log/0.4.11/src/lib.rs:809:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log/0.4.11/src/lib.rs:818:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log/0.4.11/src/lib.rs:908:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log/0.4.11/src/lib.rs:908:5 clippy::new_without_default "you should consider adding a `Default` implementation for `RecordBuilder<'a>`"
+log/0.4.11/src/lib.rs:995:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2/1.0.24/src/detection.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+proc-macro2/1.0.24/src/fallback.rs:108:17 clippy::match_wildcard_for_single_variants "wildcard match will miss any future added variants"
+proc-macro2/1.0.24/src/fallback.rs:269:20 clippy::unused_self "unused `self` argument"
+proc-macro2/1.0.24/src/fallback.rs:430:24 clippy::trivially_copy_pass_by_ref "this argument (0 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+proc-macro2/1.0.24/src/fallback.rs:437:23 clippy::trivially_copy_pass_by_ref "this argument (0 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+proc-macro2/1.0.24/src/fallback.rs:437:23 clippy::unused_self "unused `self` argument"
+proc-macro2/1.0.24/src/fallback.rs:471:17 clippy::trivially_copy_pass_by_ref "this argument (0 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+proc-macro2/1.0.24/src/fallback.rs:471:17 clippy::unused_self "unused `self` argument"
+proc-macro2/1.0.24/src/fallback.rs:654:5 clippy::manual_range_contains "manual `RangeInclusive::contains` implementation"
+proc-macro2/1.0.24/src/fallback.rs:655:12 clippy::manual_range_contains "manual `RangeInclusive::contains` implementation"
+proc-macro2/1.0.24/src/fallback.rs:661:5 clippy::manual_range_contains "manual `RangeInclusive::contains` implementation"
+proc-macro2/1.0.24/src/fallback.rs:662:12 clippy::manual_range_contains "manual `RangeInclusive::contains` implementation"
+proc-macro2/1.0.24/src/fallback.rs:664:12 clippy::manual_range_contains "manual `RangeInclusive::contains` implementation"
+proc-macro2/1.0.24/src/fallback.rs:674:37 clippy::manual_range_contains "manual `RangeInclusive::contains` implementation"
+proc-macro2/1.0.24/src/fallback.rs:678:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+proc-macro2/1.0.24/src/fallback.rs:85:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+proc-macro2/1.0.24/src/fallback.rs:882:43 clippy::unused_self "unused `self` argument"
+proc-macro2/1.0.24/src/lib.rs:1017:9 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2/1.0.24/src/lib.rs:1081:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2/1.0.24/src/lib.rs:1099:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2/1.0.24/src/lib.rs:1117:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2/1.0.24/src/lib.rs:1135:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2/1.0.24/src/lib.rs:1141:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2/1.0.24/src/lib.rs:1146:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2/1.0.24/src/lib.rs:1151:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2/1.0.24/src/lib.rs:1156:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2/1.0.24/src/lib.rs:152:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2/1.0.24/src/lib.rs:157:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2/1.0.24/src/lib.rs:373:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2/1.0.24/src/lib.rs:383:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2/1.0.24/src/lib.rs:397:24 clippy::trivially_copy_pass_by_ref "this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+proc-macro2/1.0.24/src/lib.rs:397:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2/1.0.24/src/lib.rs:403:23 clippy::trivially_copy_pass_by_ref "this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+proc-macro2/1.0.24/src/lib.rs:403:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2/1.0.24/src/lib.rs:418:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2/1.0.24/src/lib.rs:425:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2/1.0.24/src/lib.rs:464:17 clippy::trivially_copy_pass_by_ref "this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+proc-macro2/1.0.24/src/lib.rs:500:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2/1.0.24/src/lib.rs:626:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2/1.0.24/src/lib.rs:633:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2/1.0.24/src/lib.rs:641:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2/1.0.24/src/lib.rs:652:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2/1.0.24/src/lib.rs:662:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2/1.0.24/src/lib.rs:672:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2/1.0.24/src/lib.rs:734:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2/1.0.24/src/lib.rs:743:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2/1.0.24/src/lib.rs:752:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2/1.0.24/src/lib.rs:757:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2/1.0.24/src/lib.rs:788:19 clippy::doc_markdown "you should put `XID_Start` between ticks in the documentation"
+proc-macro2/1.0.24/src/lib.rs:788:69 clippy::doc_markdown "you should put `XID_Continue` between ticks in the documentation"
+proc-macro2/1.0.24/src/lib.rs:891:36 clippy::doc_markdown "you should put `syn::parse_str` between ticks in the documentation"
+proc-macro2/1.0.24/src/lib.rs:894:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2/1.0.24/src/lib.rs:911:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2/1.0.24/src/lib.rs:996:9 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2/1.0.24/src/parse.rs:552:5 clippy::while_let_on_iterator "this loop could be written as a `for` loop"
+proc-macro2/1.0.24/src/parse.rs:584:21 clippy::manual_range_contains "manual `RangeInclusive::contains` implementation"
+proc-macro2/1.0.24/src/parse.rs:602:20 clippy::map_unwrap_or "called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead"
+proc-macro2/1.0.24/src/parse.rs:696:29 clippy::cast_lossless "casting `u8` to `u64` may become silently lossy if you later change the type"
+proc-macro2/1.0.24/src/parse.rs:702:34 clippy::cast_lossless "casting `u8` to `u64` may become silently lossy if you later change the type"
+proc-macro2/1.0.24/src/parse.rs:708:34 clippy::cast_lossless "casting `u8` to `u64` may become silently lossy if you later change the type"
+proc-macro2/1.0.24/src/parse.rs:803:15 clippy::explicit_iter_loop "it is more concise to loop over references to containers instead of using explicit iteration methods"
+proc-macro2/1.0.24/src/parse.rs:808:15 clippy::explicit_iter_loop "it is more concise to loop over references to containers instead of using explicit iteration methods"
+proc-macro2/1.0.24/src/wrapper.rs:415:24 clippy::trivially_copy_pass_by_ref "this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+proc-macro2/1.0.24/src/wrapper.rs:429:23 clippy::trivially_copy_pass_by_ref "this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+proc-macro2/1.0.24/src/wrapper.rs:492:17 clippy::trivially_copy_pass_by_ref "this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+quote/1.0.7/src/ext.rs:10:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+quote/1.0.7/src/ext.rs:7:5 clippy::doc_markdown "you should put `TokenStream` between ticks in the documentation"
+quote/1.0.7/src/ident_fragment.rs:13:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+quote/1.0.7/src/ident_fragment.rs:51:31 clippy::manual_strip "stripping a prefix manually"
+quote/1.0.7/src/runtime.rs:52:5 clippy::module_name_repetitions "item name ends with its containing module's name"
+quote/1.0.7/src/runtime.rs:63:5 clippy::module_name_repetitions "item name ends with its containing module's name"
+quote/1.0.7/src/runtime.rs:66:33 clippy::doc_markdown "you should put `DoesNotHaveIter` between ticks in the documentation"
+quote/1.0.7/src/runtime.rs:80:5 clippy::module_name_repetitions "item name ends with its containing module's name"
+rand/0.7.3/src/distributions/bernoulli.rs:103:20 clippy::cast_possible_truncation "casting `f64` to `u64` may truncate the value"
+rand/0.7.3/src/distributions/bernoulli.rs:103:20 clippy::cast_sign_loss "casting `f64` to `u64` may lose the sign of the value"
+rand/0.7.3/src/distributions/bernoulli.rs:116:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+rand/0.7.3/src/distributions/bernoulli.rs:123:21 clippy::cast_possible_truncation "casting `f64` to `u64` may truncate the value"
+rand/0.7.3/src/distributions/bernoulli.rs:123:21 clippy::cast_sign_loss "casting `f64` to `u64` may lose the sign of the value"
+rand/0.7.3/src/distributions/bernoulli.rs:63:26 clippy::cast_precision_loss "casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand/0.7.3/src/distributions/bernoulli.rs:63:27 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+rand/0.7.3/src/distributions/bernoulli.rs:67:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand/0.7.3/src/distributions/bernoulli.rs:95:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+rand/0.7.3/src/distributions/bernoulli.rs:96:13 clippy::manual_range_contains "manual `Range::contains` implementation"
+rand/0.7.3/src/distributions/binomial.rs:107:23 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand/0.7.3/src/distributions/binomial.rs:112:44 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand/0.7.3/src/distributions/binomial.rs:116:13 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rand/0.7.3/src/distributions/binomial.rs:150:28 clippy::redundant_else "redundant else block"
+rand/0.7.3/src/distributions/binomial.rs:153:24 clippy::if_not_else "unnecessary boolean `not` operation"
+rand/0.7.3/src/distributions/binomial.rs:158:28 clippy::redundant_else "redundant else block"
+rand/0.7.3/src/distributions/binomial.rs:164:33 clippy::cast_sign_loss "casting `i64` to `u64` may lose the sign of the value"
+rand/0.7.3/src/distributions/binomial.rs:166:28 clippy::redundant_else "redundant else block"
+rand/0.7.3/src/distributions/binomial.rs:175:47 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand/0.7.3/src/distributions/binomial.rs:185:38 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand/0.7.3/src/distributions/binomial.rs:194:38 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand/0.7.3/src/distributions/binomial.rs:202:28 clippy::redundant_else "redundant else block"
+rand/0.7.3/src/distributions/binomial.rs:209:25 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand/0.7.3/src/distributions/binomial.rs:221:26 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand/0.7.3/src/distributions/binomial.rs:222:26 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand/0.7.3/src/distributions/binomial.rs:223:25 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand/0.7.3/src/distributions/binomial.rs:224:25 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand/0.7.3/src/distributions/binomial.rs:226:17 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rand/0.7.3/src/distributions/binomial.rs:233:32 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand/0.7.3/src/distributions/binomial.rs:234:27 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand/0.7.3/src/distributions/binomial.rs:251:22 clippy::cast_sign_loss "casting `i64` to `u64` may lose the sign of the value"
+rand/0.7.3/src/distributions/binomial.rs:255:9 clippy::if_not_else "unnecessary `!=` operation"
+rand/0.7.3/src/distributions/binomial.rs:35:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand/0.7.3/src/distributions/binomial.rs:45:17 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand/0.7.3/src/distributions/binomial.rs:46:5 clippy::cast_possible_truncation "casting `f64` to `i64` may truncate the value"
+rand/0.7.3/src/distributions/binomial.rs:50:5 clippy::too_many_lines "this function has too many lines (143/100)"
+rand/0.7.3/src/distributions/binomial.rs:76:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rand/0.7.3/src/distributions/binomial.rs:78:12 clippy::cast_precision_loss "casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand/0.7.3/src/distributions/binomial.rs:81:21 clippy::cast_precision_loss "casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand/0.7.3/src/distributions/binomial.rs:82:32 clippy::cast_possible_truncation "casting `u64` to `i32` may truncate the value"
+rand/0.7.3/src/distributions/binomial.rs:88:26 clippy::cast_precision_loss "casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand/0.7.3/src/distributions/binomial.rs:99:21 clippy::cast_precision_loss "casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand/0.7.3/src/distributions/cauchy.rs:33:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand/0.7.3/src/distributions/dirichlet.rs:52:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand/0.7.3/src/distributions/dirichlet.rs:64:32 clippy::unseparated_literal_suffix "float type suffix should be separated by an underscore"
+rand/0.7.3/src/distributions/dirichlet.rs:65:23 clippy::unseparated_literal_suffix "float type suffix should be separated by an underscore"
+rand/0.7.3/src/distributions/exponential.rs:76:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand/0.7.3/src/distributions/float.rs:73:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+rand/0.7.3/src/distributions/gamma.rs:13:5 clippy::enum_glob_use "usage of wildcard import for enum variants"
+rand/0.7.3/src/distributions/gamma.rs:14:5 clippy::enum_glob_use "usage of wildcard import for enum variants"
+rand/0.7.3/src/distributions/gamma.rs:189:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand/0.7.3/src/distributions/gamma.rs:230:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand/0.7.3/src/distributions/gamma.rs:259:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand/0.7.3/src/distributions/gamma.rs:287:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand/0.7.3/src/distributions/gamma.rs:90:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand/0.7.3/src/distributions/integer.rs:23:9 clippy::cast_possible_truncation "casting `u32` to `u8` may truncate the value"
+rand/0.7.3/src/distributions/integer.rs:30:9 clippy::cast_possible_truncation "casting `u32` to `u16` may truncate the value"
+rand/0.7.3/src/distributions/integer.rs:69:9 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
+rand/0.7.3/src/distributions/mod.rs:263:5 clippy::inline_always "you have declared `#[inline(always)]` on `next`. This is usually a bad idea"
+rand/0.7.3/src/distributions/normal.rs:100:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand/0.7.3/src/distributions/normal.rs:119:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+rand/0.7.3/src/distributions/normal.rs:131:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand/0.7.3/src/distributions/normal.rs:31:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+rand/0.7.3/src/distributions/normal.rs:47:25 clippy::unseparated_literal_suffix "float type suffix should be separated by an underscore"
+rand/0.7.3/src/distributions/normal.rs:48:25 clippy::unseparated_literal_suffix "float type suffix should be separated by an underscore"
+rand/0.7.3/src/distributions/other.rs:89:9 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
+rand/0.7.3/src/distributions/pareto.rs:32:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand/0.7.3/src/distributions/poisson.rs:35:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand/0.7.3/src/distributions/poisson.rs:87:30 clippy::cast_possible_truncation "casting `f64` to `u64` may truncate the value"
+rand/0.7.3/src/distributions/poisson.rs:87:30 clippy::cast_sign_loss "casting `f64` to `u64` may lose the sign of the value"
+rand/0.7.3/src/distributions/triangular.rs:32:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand/0.7.3/src/distributions/uniform.rs:146:4 clippy::needless_doctest_main "needless `fn main` in doctest"
+rand/0.7.3/src/distributions/uniform.rs:199:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+rand/0.7.3/src/distributions/uniform.rs:214:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand/0.7.3/src/distributions/uniform.rs:283:14 clippy::doc_markdown "you should put `SampleUniform` between ticks in the documentation"
+rand/0.7.3/src/distributions/uniform.rs:283:46 clippy::doc_markdown "you should put `SampleUniform` between ticks in the documentation"
+rand/0.7.3/src/distributions/uniform.rs:296:5 clippy::inline_always "you have declared `#[inline(always)]` on `borrow`. This is usually a bad idea"
+rand/0.7.3/src/distributions/uniform.rs:304:5 clippy::inline_always "you have declared `#[inline(always)]` on `borrow`. This is usually a bad idea"
+rand/0.7.3/src/distributions/uniform.rs:350:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand/0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
+rand/0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
+rand/0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
+rand/0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
+rand/0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
+rand/0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
+rand/0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
+rand/0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
+rand/0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
+rand/0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
+rand/0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
+rand/0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
+rand/0.7.3/src/distributions/uniform.rs:441:31 clippy::invalid_upcast_comparisons "because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false"
+rand/0.7.3/src/distributions/uniform.rs:441:31 clippy::invalid_upcast_comparisons "because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false"
+rand/0.7.3/src/distributions/uniform.rs:441:31 clippy::invalid_upcast_comparisons "because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false"
+rand/0.7.3/src/distributions/uniform.rs:441:31 clippy::invalid_upcast_comparisons "because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false"
+rand/0.7.3/src/distributions/uniform.rs:441:31 clippy::invalid_upcast_comparisons "because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false"
+rand/0.7.3/src/distributions/uniform.rs:441:31 clippy::invalid_upcast_comparisons "because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false"
+rand/0.7.3/src/distributions/uniform.rs:441:31 clippy::invalid_upcast_comparisons "because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false"
+rand/0.7.3/src/distributions/uniform.rs:441:31 clippy::invalid_upcast_comparisons "because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false"
+rand/0.7.3/src/distributions/uniform.rs:56:10 clippy::doc_markdown "you should put `SampleBorrow` between ticks in the documentation"
+rand/0.7.3/src/distributions/uniform.rs:647:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand/0.7.3/src/distributions/uniform.rs:840:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand/0.7.3/src/distributions/uniform.rs:913:13 clippy::option_if_let_else "use Option::map_or_else instead of an if let/else"
+rand/0.7.3/src/distributions/uniform.rs:943:54 clippy::cast_possible_truncation "casting `u64` to `u32` may truncate the value"
+rand/0.7.3/src/distributions/unit_circle.rs:30:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand/0.7.3/src/distributions/unit_sphere.rs:24:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand/0.7.3/src/distributions/unit_sphere.rs:29:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand/0.7.3/src/distributions/utils.rs:247:15 clippy::wrong_self_convention "methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name"
+rand/0.7.3/src/distributions/utils.rs:248:20 clippy::wrong_self_convention "methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name"
+rand/0.7.3/src/distributions/utils.rs:249:18 clippy::wrong_self_convention "methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name"
+rand/0.7.3/src/distributions/utils.rs:254:5 clippy::inline_always "you have declared `#[inline(always)]` on `lanes`. This is usually a bad idea"
+rand/0.7.3/src/distributions/utils.rs:258:5 clippy::inline_always "you have declared `#[inline(always)]` on `splat`. This is usually a bad idea"
+rand/0.7.3/src/distributions/utils.rs:262:5 clippy::inline_always "you have declared `#[inline(always)]` on `extract`. This is usually a bad idea"
+rand/0.7.3/src/distributions/utils.rs:267:5 clippy::inline_always "you have declared `#[inline(always)]` on `replace`. This is usually a bad idea"
+rand/0.7.3/src/distributions/utils.rs:281:5 clippy::inline_always "you have declared `#[inline(always)]` on `any`. This is usually a bad idea"
+rand/0.7.3/src/distributions/utils.rs:286:5 clippy::inline_always "you have declared `#[inline(always)]` on `all`. This is usually a bad idea"
+rand/0.7.3/src/distributions/utils.rs:291:5 clippy::inline_always "you have declared `#[inline(always)]` on `none`. This is usually a bad idea"
+rand/0.7.3/src/distributions/utils.rs:488:17 clippy::doc_markdown "you should put `x_i` between ticks in the documentation"
+rand/0.7.3/src/distributions/utils.rs:489:50 clippy::doc_markdown "you should put `x_i` between ticks in the documentation"
+rand/0.7.3/src/distributions/utils.rs:489:63 clippy::doc_markdown "you should put `f(x_i` between ticks in the documentation"
+rand/0.7.3/src/distributions/utils.rs:490:40 clippy::doc_markdown "you should put `f(x_i` between ticks in the documentation"
+rand/0.7.3/src/distributions/utils.rs:490:49 clippy::doc_markdown "you should put `f(x_{i+1` between ticks in the documentation"
+rand/0.7.3/src/distributions/utils.rs:518:17 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
+rand/0.7.3/src/distributions/weibull.rs:29:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand/0.7.3/src/distributions/weighted/alias_method.rs:113:21 clippy::explicit_iter_loop "it is more concise to loop over references to containers instead of using explicit iteration methods"
+rand/0.7.3/src/distributions/weighted/alias_method.rs:125:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rand/0.7.3/src/distributions/weighted/alias_method.rs:131:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rand/0.7.3/src/distributions/weighted/alias_method.rs:180:36 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+rand/0.7.3/src/distributions/weighted/alias_method.rs:182:34 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+rand/0.7.3/src/distributions/weighted/alias_method.rs:259:28 clippy::clone_on_copy "using `clone` on type `distributions::uniform::Uniform<u32>` which implements the `Copy` trait"
+rand/0.7.3/src/distributions/weighted/alias_method.rs:296:9 clippy::map_clone "you are using an explicit closure for copying elements"
+rand/0.7.3/src/distributions/weighted/alias_method.rs:321:9 clippy::map_clone "you are using an explicit closure for copying elements"
+rand/0.7.3/src/distributions/weighted/alias_method.rs:78:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+rand/0.7.3/src/distributions/weighted/alias_method.rs:78:5 clippy::too_many_lines "this function has too many lines (106/100)"
+rand/0.7.3/src/distributions/weighted/alias_method.rs:85:17 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+rand/0.7.3/src/distributions/weighted/alias_method.rs:87:31 clippy::map_unwrap_or "called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead"
+rand/0.7.3/src/distributions/weighted/mod.rs:100:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+rand/0.7.3/src/distributions/weighted/mod.rs:144:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+rand/0.7.3/src/distributions/weighted/mod.rs:169:16 clippy::int_plus_one "unnecessary `>= y + 1` or `x - 1 >=`"
+rand/0.7.3/src/distributions/weighted/mod.rs:386:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand/0.7.3/src/distributions/weighted/mod.rs:85:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand/0.7.3/src/lib.rs:333:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+rand/0.7.3/src/lib.rs:404:14 clippy::wrong_self_convention "methods called `to_*` usually take self by reference; consider choosing a less ambiguous name"
+rand/0.7.3/src/lib.rs:552:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+rand/0.7.3/src/rngs/adapter/read.rs:47:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand/0.7.3/src/rngs/adapter/read.rs:89:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand/0.7.3/src/rngs/adapter/reseeding.rs:100:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+rand/0.7.3/src/rngs/adapter/reseeding.rs:112:5 clippy::inline_always "you have declared `#[inline(always)]` on `next_u32`. This is usually a bad idea"
+rand/0.7.3/src/rngs/adapter/reseeding.rs:117:5 clippy::inline_always "you have declared `#[inline(always)]` on `next_u64`. This is usually a bad idea"
+rand/0.7.3/src/rngs/adapter/reseeding.rs:198:13 clippy::cast_possible_wrap "casting `u64` to `i64` may wrap around the value"
+rand/0.7.3/src/rngs/adapter/reseeding.rs:231:9 clippy::cast_possible_wrap "casting `usize` to `isize` may wrap around the value"
+rand/0.7.3/src/rngs/adapter/reseeding.rs:27:28 clippy::doc_markdown "you should put `ChaCha` between ticks in the documentation"
+rand/0.7.3/src/rngs/adapter/reseeding.rs:79:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand/0.7.3/src/rngs/entropy.rs:24:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand/0.7.3/src/rngs/entropy.rs:34:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand/0.7.3/src/rngs/mock.rs:36:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand/0.7.3/src/rngs/mock.rs:47:9 clippy::cast_possible_truncation "casting `u64` to `u32` may truncate the value"
+rand/0.7.3/src/rngs/mod.rs:61:74 clippy::doc_markdown "you should put `ChaCha20` between ticks in the documentation"
+rand/0.7.3/src/rngs/std.rs:25:39 clippy::doc_markdown "you should put `ChaCha` between ticks in the documentation"
+rand/0.7.3/src/rngs/std.rs:32:10 clippy::doc_markdown "you should put `rand_chacha` between ticks in the documentation"
+rand/0.7.3/src/rngs/std.rs:36:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand/0.7.3/src/rngs/std.rs:39:5 clippy::inline_always "you have declared `#[inline(always)]` on `next_u32`. This is usually a bad idea"
+rand/0.7.3/src/rngs/std.rs:44:5 clippy::inline_always "you have declared `#[inline(always)]` on `next_u64`. This is usually a bad idea"
+rand/0.7.3/src/rngs/std.rs:49:5 clippy::inline_always "you have declared `#[inline(always)]` on `fill_bytes`. This is usually a bad idea"
+rand/0.7.3/src/rngs/std.rs:54:5 clippy::inline_always "you have declared `#[inline(always)]` on `try_fill_bytes`. This is usually a bad idea"
+rand/0.7.3/src/rngs/std.rs:63:5 clippy::inline_always "you have declared `#[inline(always)]` on `from_seed`. This is usually a bad idea"
+rand/0.7.3/src/rngs/std.rs:68:5 clippy::inline_always "you have declared `#[inline(always)]` on `from_rng`. This is usually a bad idea"
+rand/0.7.3/src/rngs/thread.rs:57:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand/0.7.3/src/rngs/thread.rs:80:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand/0.7.3/src/rngs/thread.rs:80:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+rand/0.7.3/src/rngs/thread.rs:81:35 clippy::redundant_closure_for_method_calls "redundant closure found"
+rand/0.7.3/src/rngs/thread.rs:93:5 clippy::inline_always "you have declared `#[inline(always)]` on `next_u32`. This is usually a bad idea"
+rand/0.7.3/src/rngs/thread.rs:98:5 clippy::inline_always "you have declared `#[inline(always)]` on `next_u64`. This is usually a bad idea"
+rand/0.7.3/src/seq/index.rs:127:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand/0.7.3/src/seq/index.rs:139:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+rand/0.7.3/src/seq/index.rs:159:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand/0.7.3/src/seq/index.rs:171:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+rand/0.7.3/src/seq/index.rs:180:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+rand/0.7.3/src/seq/index.rs:223:18 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+rand/0.7.3/src/seq/index.rs:224:18 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+rand/0.7.3/src/seq/index.rs:233:25 clippy::cast_precision_loss "casting `u32` to `f32` causes a loss of precision (`u32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)"
+rand/0.7.3/src/seq/index.rs:236:27 clippy::cast_precision_loss "casting `u32` to `f32` causes a loss of precision (`u32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)"
+rand/0.7.3/src/seq/index.rs:244:12 clippy::cast_precision_loss "casting `u32` to `f32` causes a loss of precision (`u32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)"
+rand/0.7.3/src/seq/index.rs:244:37 clippy::cast_precision_loss "casting `u32` to `f32` causes a loss of precision (`u32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)"
+rand/0.7.3/src/seq/index.rs:29:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand/0.7.3/src/seq/index.rs:39:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand/0.7.3/src/seq/index.rs:48:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand/0.7.3/src/seq/index.rs:60:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand/0.7.3/src/seq/index.rs:69:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand/0.7.3/src/seq/index.rs:78:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand/0.7.3/src/seq/index.rs:87:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand/0.7.3/src/seq/index.rs:87:5 clippy::should_implement_trait "method `into_iter` can be confused for the standard trait method `std::iter::IntoIterator::into_iter`"
+rand/0.7.3/src/seq/index.rs:97:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+rand/0.7.3/src/seq/mod.rs:141:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+rand/0.7.3/src/seq/mod.rs:168:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+rand/0.7.3/src/seq/mod.rs:229:4 clippy::needless_doctest_main "needless `fn main` in doctest"
+rand/0.7.3/src/seq/mod.rs:292:29 clippy::cast_precision_loss "casting `usize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`usize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand/0.7.3/src/seq/mod.rs:410:23 clippy::default_trait_access "calling `std::marker::PhantomData::default()` is more clear than this expression"
+rand/0.7.3/src/seq/mod.rs:45:4 clippy::needless_doctest_main "needless `fn main` in doctest"
+rand/0.7.3/src/seq/mod.rs:527:26 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+rand_core/0.6.0/src/block.rs:117:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand_core/0.6.0/src/block.rs:153:5 clippy::inline_always "you have declared `#[inline(always)]` on `index`. This is usually a bad idea"
+rand_core/0.6.0/src/block.rs:230:5 clippy::inline_always "you have declared `#[inline(always)]` on `try_fill_bytes`. This is usually a bad idea"
+rand_core/0.6.0/src/block.rs:240:5 clippy::inline_always "you have declared `#[inline(always)]` on `from_seed`. This is usually a bad idea"
+rand_core/0.6.0/src/block.rs:245:5 clippy::inline_always "you have declared `#[inline(always)]` on `seed_from_u64`. This is usually a bad idea"
+rand_core/0.6.0/src/block.rs:250:5 clippy::inline_always "you have declared `#[inline(always)]` on `from_rng`. This is usually a bad idea"
+rand_core/0.6.0/src/block.rs:280:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand_core/0.6.0/src/block.rs:319:5 clippy::inline_always "you have declared `#[inline(always)]` on `index`. This is usually a bad idea"
+rand_core/0.6.0/src/block.rs:405:5 clippy::inline_always "you have declared `#[inline(always)]` on `try_fill_bytes`. This is usually a bad idea"
+rand_core/0.6.0/src/block.rs:415:5 clippy::inline_always "you have declared `#[inline(always)]` on `from_seed`. This is usually a bad idea"
+rand_core/0.6.0/src/block.rs:420:5 clippy::inline_always "you have declared `#[inline(always)]` on `seed_from_u64`. This is usually a bad idea"
+rand_core/0.6.0/src/block.rs:425:5 clippy::inline_always "you have declared `#[inline(always)]` on `from_rng`. This is usually a bad idea"
+rand_core/0.6.0/src/block.rs:67:14 clippy::doc_markdown "you should put `module][crate::block` between ticks in the documentation"
+rand_core/0.6.0/src/block.rs:68:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand_core/0.6.0/src/error.rs:106:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand_core/0.6.0/src/error.rs:87:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand_core/0.6.0/src/error.rs:95:74 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
+rand_core/0.6.0/src/lib.rs:179:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+rand_core/0.6.0/src/lib.rs:301:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand_core/0.6.0/src/lib.rs:303:26 clippy::unreadable_literal "long literal lacking separators"
+rand_core/0.6.0/src/lib.rs:304:26 clippy::unreadable_literal "long literal lacking separators"
+rand_core/0.6.0/src/lib.rs:313:30 clippy::cast_possible_truncation "casting `u64` to `u32` may truncate the value"
+rand_core/0.6.0/src/lib.rs:314:23 clippy::cast_possible_truncation "casting `u64` to `u32` may truncate the value"
+rand_core/0.6.0/src/lib.rs:346:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+rand_core/0.6.0/src/lib.rs:381:5 clippy::inline_always "you have declared `#[inline(always)]` on `next_u32`. This is usually a bad idea"
+rand_core/0.6.0/src/lib.rs:386:5 clippy::inline_always "you have declared `#[inline(always)]` on `next_u64`. This is usually a bad idea"
+rand_core/0.6.0/src/lib.rs:391:5 clippy::inline_always "you have declared `#[inline(always)]` on `fill_bytes`. This is usually a bad idea"
+rand_core/0.6.0/src/lib.rs:396:5 clippy::inline_always "you have declared `#[inline(always)]` on `try_fill_bytes`. This is usually a bad idea"
+rayon/1.5.0/src/collections/binary_heap.rs:7:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/collections/binary_heap.rs:8:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/collections/btree_map.rs:7:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/collections/btree_map.rs:8:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/collections/btree_set.rs:7:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/collections/btree_set.rs:8:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/collections/hash_map.rs:10:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/collections/hash_map.rs:9:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/collections/hash_set.rs:10:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/collections/hash_set.rs:9:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/collections/linked_list.rs:7:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/collections/linked_list.rs:8:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/collections/mod.rs:59:32 clippy::mem_replace_with_default "replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`"
+rayon/1.5.0/src/collections/vec_deque.rs:8:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/collections/vec_deque.rs:9:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/compile_fail/cannot_collect_filtermap_data.rs:2:1 clippy::needless_doctest_main "needless `fn main` in doctest"
+rayon/1.5.0/src/compile_fail/cannot_zip_filtered_data.rs:2:1 clippy::needless_doctest_main "needless `fn main` in doctest"
+rayon/1.5.0/src/compile_fail/cell_par_iter.rs:2:1 clippy::needless_doctest_main "needless `fn main` in doctest"
+rayon/1.5.0/src/compile_fail/no_send_par_iter.rs:25:1 clippy::needless_doctest_main "needless `fn main` in doctest"
+rayon/1.5.0/src/compile_fail/no_send_par_iter.rs:46:1 clippy::needless_doctest_main "needless `fn main` in doctest"
+rayon/1.5.0/src/compile_fail/no_send_par_iter.rs:4:1 clippy::needless_doctest_main "needless `fn main` in doctest"
+rayon/1.5.0/src/compile_fail/rc_par_iter.rs:2:1 clippy::needless_doctest_main "needless `fn main` in doctest"
+rayon/1.5.0/src/iter/chain.rs:103:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/chain.rs:122:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/chain.rs:128:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/chain.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/chain.rs:221:36 clippy::doc_markdown "you should put `ExactSizeIterator` between ticks in the documentation"
+rayon/1.5.0/src/iter/chain.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/chain.rs:51:38 clippy::option_if_let_else "use Option::map_or_else instead of an if let/else"
+rayon/1.5.0/src/iter/chain.rs:58:14 clippy::shadow_unrelated "`a` is being shadowed"
+rayon/1.5.0/src/iter/chain.rs:58:17 clippy::shadow_unrelated "`b` is being shadowed"
+rayon/1.5.0/src/iter/chain.rs:78:14 clippy::shadow_unrelated "`a` is being shadowed"
+rayon/1.5.0/src/iter/chain.rs:78:17 clippy::shadow_unrelated "`b` is being shadowed"
+rayon/1.5.0/src/iter/chain.rs:97:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/chunks.rs:3:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/chunks.rs:4:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/chunks.rs:77:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/chunks.rs:83:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/cloned.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/cloned.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/cloned.rs:71:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/cloned.rs:75:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/collect/consumer.rs:141:5 clippy::doc_markdown "you should put `CollectReducer` between ticks in the documentation"
+rayon/1.5.0/src/iter/collect/consumer.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/collect/consumer.rs:28:5 clippy::doc_markdown "you should put `CollectResult` between ticks in the documentation"
+rayon/1.5.0/src/iter/collect/consumer.rs:36:37 clippy::mut_mut "generally you want to avoid `&mut &mut _` if possible"
+rayon/1.5.0/src/iter/collect/consumer.rs:36:37 clippy::mut_mut "generally you want to avoid `&mut &mut _` if possible"
+rayon/1.5.0/src/iter/collect/mod.rs:154:9 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+rayon/1.5.0/src/iter/copied.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/copied.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/copied.rs:71:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/copied.rs:75:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/empty.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/empty.rs:24:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+rayon/1.5.0/src/iter/empty.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/enumerate.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/enumerate.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/enumerate.rs:64:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/enumerate.rs:68:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/extend.rs:143:63 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
+rayon/1.5.0/src/iter/extend.rs:182:57 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
+rayon/1.5.0/src/iter/extend.rs:218:32 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
+rayon/1.5.0/src/iter/extend.rs:218:59 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
+rayon/1.5.0/src/iter/extend.rs:25:42 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
+rayon/1.5.0/src/iter/extend.rs:287:62 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
+rayon/1.5.0/src/iter/extend.rs:322:56 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
+rayon/1.5.0/src/iter/extend.rs:41:27 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
+rayon/1.5.0/src/iter/extend.rs:47:30 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
+rayon/1.5.0/src/iter/extend.rs:47:56 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
+rayon/1.5.0/src/iter/extend.rs:47:74 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
+rayon/1.5.0/src/iter/extend.rs:53:29 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
+rayon/1.5.0/src/iter/extend.rs:57:36 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
+rayon/1.5.0/src/iter/extend.rs:59:61 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
+rayon/1.5.0/src/iter/filter.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/filter.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/filter_map.rs:123:9 clippy::option_if_let_else "use Option::map_or instead of an if let/else"
+rayon/1.5.0/src/iter/filter_map.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/filter_map.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/find.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/find.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/find_first_last/mod.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/find_first_last/mod.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/find_first_last/mod.rs:32:67 clippy::doc_markdown "you should put `MatchPosition` between ticks in the documentation"
+rayon/1.5.0/src/iter/flat_map.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/flat_map.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/flat_map_iter.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/flat_map_iter.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/flatten.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/flatten.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/flatten_iter.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/flatten_iter.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/fold.rs:158:13 clippy::similar_names "binding's name is too similar to existing binding"
+rayon/1.5.0/src/iter/fold.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/fold.rs:204:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rayon/1.5.0/src/iter/fold.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/for_each.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/for_each.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/inspect.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/inspect.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/inspect.rs:83:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/inspect.rs:88:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/interleave.rs:111:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/interleave.rs:119:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/interleave.rs:195:30 clippy::doc_markdown "you should put `self.i_len` between ticks in the documentation"
+rayon/1.5.0/src/iter/interleave.rs:195:43 clippy::doc_markdown "you should put `self.j_len` between ticks in the documentation"
+rayon/1.5.0/src/iter/interleave.rs:199:23 clippy::doc_markdown "you should put `self.i_len` between ticks in the documentation"
+rayon/1.5.0/src/iter/interleave.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/interleave.rs:200:23 clippy::doc_markdown "you should put `self.j_len` between ticks in the documentation"
+rayon/1.5.0/src/iter/interleave.rs:249:41 clippy::doc_markdown "you should put `DoubleEndedIterator` between ticks in the documentation"
+rayon/1.5.0/src/iter/interleave.rs:250:5 clippy::doc_markdown "you should put `ExactSizeIterator` between ticks in the documentation"
+rayon/1.5.0/src/iter/interleave.rs:263:33 clippy::doc_markdown "you should put `InterleaveSeq` between ticks in the documentation"
+rayon/1.5.0/src/iter/interleave.rs:280:17 clippy::match_wildcard_for_single_variants "wildcard match will miss any future added variants"
+rayon/1.5.0/src/iter/interleave.rs:285:17 clippy::match_wildcard_for_single_variants "wildcard match will miss any future added variants"
+rayon/1.5.0/src/iter/interleave.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/interleave.rs:313:9 clippy::comparison_chain "`if` chain can be rewritten with `match`"
+rayon/1.5.0/src/iter/interleave.rs:82:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/interleave.rs:90:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/interleave_shortest.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/intersperse.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/intersperse.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/intersperse.rs:90:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/intersperse.rs:96:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/len.rs:12:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+rayon/1.5.0/src/iter/len.rs:146:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+rayon/1.5.0/src/iter/len.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/len.rs:200:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/len.rs:205:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/len.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/len.rs:66:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/len.rs:71:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/map.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/map.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/map.rs:84:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/map.rs:89:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/map_with.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/map_with.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/map_with.rs:419:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/map_with.rs:425:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/map_with.rs:90:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/map_with.rs:96:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/mod.rs:1874:24 clippy::trivially_copy_pass_by_ref "this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+rayon/1.5.0/src/iter/mod.rs:2171:1 clippy::len_without_is_empty "trait `IndexedParallelIterator` has a `len` method but no (possibly inherited) `is_empty` method"
+rayon/1.5.0/src/iter/mod.rs:2371:26 clippy::trivially_copy_pass_by_ref "this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+rayon/1.5.0/src/iter/mod.rs:2411:26 clippy::trivially_copy_pass_by_ref "this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+rayon/1.5.0/src/iter/mod.rs:82:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/multizip.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/multizip.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/noop.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/once.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/once.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/panic_fuse.rs:102:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/panic_fuse.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/panic_fuse.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/panic_fuse.rs:98:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/par_bridge.rs:136:28 clippy::redundant_else "redundant else block"
+rayon/1.5.0/src/iter/par_bridge.rs:163:28 clippy::redundant_else "redundant else block"
+rayon/1.5.0/src/iter/plumbing/mod.rs:216:58 clippy::doc_markdown "you should put `find_first` between ticks in the documentation"
+rayon/1.5.0/src/iter/plumbing/mod.rs:359:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/plumbing/mod.rs:364:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/plumbing/mod.rs:399:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/plumbing/mod.rs:53:19 clippy::doc_markdown "you should put `DoubleEndedIterator` between ticks in the documentation"
+rayon/1.5.0/src/iter/plumbing/mod.rs:53:43 clippy::doc_markdown "you should put `ExactSizeIterator` between ticks in the documentation"
+rayon/1.5.0/src/iter/plumbing/mod.rs:54:31 clippy::doc_markdown "you should put `IntoIterator` between ticks in the documentation"
+rayon/1.5.0/src/iter/plumbing/mod.rs:55:5 clippy::doc_markdown "you should put `IntoIterator` between ticks in the documentation"
+rayon/1.5.0/src/iter/positions.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/positions.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/product.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/reduce.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/repeat.rs:103:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rayon/1.5.0/src/iter/repeat.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/repeat.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/rev.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/rev.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/rev.rs:63:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/rev.rs:68:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/skip.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/skip.rs:3:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/skip.rs:68:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/skip.rs:73:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/splitter.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/splitter.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/step_by.rs:4:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/step_by.rs:5:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/step_by.rs:73:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/step_by.rs:79:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/sum.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/take.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/take.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/take.rs:67:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/take.rs:72:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/try_fold.rs:190:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rayon/1.5.0/src/iter/try_fold.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/try_fold.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/try_reduce.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/try_reduce_with.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/unzip.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/unzip.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/update.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/update.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/update.rs:82:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/update.rs:87:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/while_some.rs:130:22 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+rayon/1.5.0/src/iter/while_some.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/while_some.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/zip.rs:102:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/zip.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/zip.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/zip.rs:74:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/zip.rs:79:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/zip.rs:97:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/iter/zip_eq.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/iter/zip_eq.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/option.rs:8:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/option.rs:9:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/par_either.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/par_either.rs:3:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/private.rs:9:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rayon/1.5.0/src/range.rs:19:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/range.rs:20:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/range_inclusive.rs:194:9 clippy::range_plus_one "an inclusive range would be more readable"
+rayon/1.5.0/src/range_inclusive.rs:194:9 clippy::range_plus_one "an inclusive range would be more readable"
+rayon/1.5.0/src/range_inclusive.rs:19:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/range_inclusive.rs:209:9 clippy::range_plus_one "an inclusive range would be more readable"
+rayon/1.5.0/src/range_inclusive.rs:209:9 clippy::range_plus_one "an inclusive range would be more readable"
+rayon/1.5.0/src/range_inclusive.rs:20:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/range_inclusive.rs:231:9 clippy::range_plus_one "an inclusive range would be more readable"
+rayon/1.5.0/src/range_inclusive.rs:231:9 clippy::range_plus_one "an inclusive range would be more readable"
+rayon/1.5.0/src/result.rs:8:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/result.rs:9:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/slice/mergesort.rs:102:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/slice/mergesort.rs:109:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/slice/mergesort.rs:114:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/slice/mergesort.rs:211:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/slice/mergesort.rs:217:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/slice/mergesort.rs:251:5 clippy::doc_markdown "you should put `TimSort` between ticks in the documentation"
+rayon/1.5.0/src/slice/mergesort.rs:252:5 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
+rayon/1.5.0/src/slice/mergesort.rs:286:59 clippy::doc_markdown "you should put `TimSort` between ticks in the documentation"
+rayon/1.5.0/src/slice/mergesort.rs:333:24 clippy::redundant_else "redundant else block"
+rayon/1.5.0/src/slice/mergesort.rs:513:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/slice/mergesort.rs:521:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/slice/mergesort.rs:7:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/slice/mergesort.rs:98:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/slice/mod.rs:15:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/slice/mod.rs:16:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/slice/mod.rs:17:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/slice/mod.rs:25:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+rayon/1.5.0/src/slice/mod.rs:657:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rayon/1.5.0/src/slice/mod.rs:971:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rayon/1.5.0/src/slice/quicksort.rs:230:36 clippy::doc_markdown "you should put `BlockQuicksort` between ticks in the documentation"
+rayon/1.5.0/src/slice/quicksort.rs:233:1 clippy::too_many_lines "this function has too many lines (117/100)"
+rayon/1.5.0/src/slice/quicksort.rs:258:26 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+rayon/1.5.0/src/slice/quicksort.rs:265:26 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+rayon/1.5.0/src/slice/quicksort.rs:268:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon/1.5.0/src/slice/quicksort.rs:308:30 clippy::cast_possible_truncation "casting `usize` to `u8` may truncate the value"
+rayon/1.5.0/src/slice/quicksort.rs:325:30 clippy::cast_possible_truncation "casting `usize` to `u8` may truncate the value"
+rayon/1.5.0/src/slice/quicksort.rs:393:36 clippy::cast_possible_wrap "casting `u8` to `isize` may wrap around the value on targets with 32-bit wide pointers"
+rayon/1.5.0/src/slice/quicksort.rs:405:40 clippy::cast_possible_wrap "casting `u8` to `isize` may wrap around the value on targets with 32-bit wide pointers"
+rayon/1.5.0/src/slice/quicksort.rs:430:14 clippy::shadow_unrelated "`pivot` is being shadowed"
+rayon/1.5.0/src/slice/quicksort.rs:439:13 clippy::shadow_unrelated "`pivot` is being shadowed"
+rayon/1.5.0/src/slice/quicksort.rs:482:10 clippy::shadow_unrelated "`pivot` is being shadowed"
+rayon/1.5.0/src/slice/quicksort.rs:491:9 clippy::shadow_unrelated "`pivot` is being shadowed"
+rayon/1.5.0/src/slice/quicksort.rs:534:26 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+rayon/1.5.0/src/slice/quicksort.rs:545:17 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
+rayon/1.5.0/src/slice/quicksort.rs:588:17 clippy::identity_op "the operation is ineffective. Consider reducing it to `len / 4`"
+rayon/1.5.0/src/slice/quicksort.rs:716:14 clippy::shadow_unrelated "`pivot` is being shadowed"
+rayon/1.5.0/src/split_producer.rs:56:16 clippy::option_if_let_else "use Option::map_or_else instead of an if let/else"
+rayon/1.5.0/src/split_producer.rs:92:9 clippy::option_if_let_else "use Option::map_or instead of an if let/else"
+rayon/1.5.0/src/str.rs:16:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/str.rs:17:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/str.rs:18:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/str.rs:25:5 clippy::cast_possible_wrap "casting `u8` to `i8` may wrap around the value"
+rayon/1.5.0/src/str.rs:715:9 clippy::manual_strip "stripping a suffix manually"
+rayon/1.5.0/src/string.rs:5:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/vec.rs:137:12 clippy::len_zero "length comparison to zero"
+rayon/1.5.0/src/vec.rs:8:5 clippy::wildcard_imports "usage of wildcard import"
+rayon/1.5.0/src/vec.rs:9:5 clippy::wildcard_imports "usage of wildcard import"
+regex/1.3.2/src/backtrack.rs:100:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/backtrack.rs:133:17 clippy::same_item_push "it looks like the same item is being pushed into this Vec"
+regex/1.3.2/src/backtrack.rs:145:20 clippy::if_not_else "unnecessary boolean `not` operation"
+regex/1.3.2/src/backtrack.rs:199:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex/1.3.2/src/backtrack.rs:223:29 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/backtrack.rs:230:66 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/backtrack.rs:284:21 clippy::cast_lossless "casting `u32` to `u64` may become silently lossy if you later change the type"
+regex/1.3.2/src/backtrack.rs:287:5 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+regex/1.3.2/src/backtrack.rs:97:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/backtrack.rs:98:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/backtrack.rs:99:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/compile.rs:1005:32 clippy::unreadable_literal "long literal lacking separators"
+regex/1.3.2/src/compile.rs:1006:21 clippy::unreadable_literal "long literal lacking separators"
+regex/1.3.2/src/compile.rs:1008:18 clippy::cast_lossless "casting `u8` to `u64` may become silently lossy if you later change the type"
+regex/1.3.2/src/compile.rs:1009:18 clippy::cast_lossless "casting `u8` to `u64` may become silently lossy if you later change the type"
+regex/1.3.2/src/compile.rs:1010:9 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
+regex/1.3.2/src/compile.rs:102:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/compile.rs:1037:37 clippy::cast_possible_truncation "casting `u16` to `u8` may truncate the value"
+regex/1.3.2/src/compile.rs:1037:55 clippy::cast_possible_truncation "casting `u16` to `u8` may truncate the value"
+regex/1.3.2/src/compile.rs:1040:28 clippy::cast_possible_truncation "casting `u16` to `u8` may truncate the value"
+regex/1.3.2/src/compile.rs:1040:38 clippy::cast_possible_truncation "casting `u16` to `u8` may truncate the value"
+regex/1.3.2/src/compile.rs:1051:25 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+regex/1.3.2/src/compile.rs:1071:8 clippy::cast_lossless "casting `u32` to `u64` may become silently lossy if you later change the type"
+regex/1.3.2/src/compile.rs:112:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+regex/1.3.2/src/compile.rs:154:30 clippy::redundant_closure_for_method_calls "redundant closure found"
+regex/1.3.2/src/compile.rs:156:30 clippy::redundant_closure_for_method_calls "redundant closure found"
+regex/1.3.2/src/compile.rs:185:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+regex/1.3.2/src/compile.rs:187:40 clippy::redundant_closure_for_method_calls "redundant closure found"
+regex/1.3.2/src/compile.rs:201:53 clippy::doc_markdown "you should put `MaybeInsts` between ticks in the documentation"
+regex/1.3.2/src/compile.rs:241:63 clippy::doc_markdown "you should put `c_concat` between ticks in the documentation"
+regex/1.3.2/src/compile.rs:245:5 clippy::too_many_lines "this function has too many lines (111/100)"
+regex/1.3.2/src/compile.rs:247:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex/1.3.2/src/compile.rs:373:24 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/compile.rs:373:36 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/compile.rs:378:12 clippy::if_not_else "unnecessary boolean `not` operation"
+regex/1.3.2/src/compile.rs:400:37 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/compile.rs:407:51 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/compile.rs:409:24 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/compile.rs:417:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+regex/1.3.2/src/compile.rs:42:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/compile.rs:42:5 clippy::new_without_default "you should consider adding a `Default` implementation for `compile::Compiler`"
+regex/1.3.2/src/compile.rs:444:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+regex/1.3.2/src/compile.rs:445:57 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/compile.rs:446:20 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/compile.rs:466:20 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/compile.rs:466:32 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/compile.rs:519:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex/1.3.2/src/compile.rs:55:57 clippy::doc_markdown "you should put `size_limit` between ticks in the documentation"
+regex/1.3.2/src/compile.rs:58:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/compile.rs:748:41 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/compile.rs:74:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/compile.rs:751:54 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/compile.rs:765:41 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/compile.rs:765:55 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/compile.rs:825:39 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/compile.rs:825:51 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/compile.rs:828:49 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/compile.rs:828:61 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/compile.rs:830:59 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/compile.rs:830:71 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/compile.rs:832:43 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/compile.rs:835:41 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/compile.rs:835:53 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/compile.rs:835:67 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/compile.rs:83:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/compile.rs:896:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+regex/1.3.2/src/compile.rs:905:17 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/compile.rs:953:17 clippy::doc_markdown "you should put `HashMap` between ticks in the documentation"
+regex/1.3.2/src/compile.rs:95:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/compile.rs:980:26 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+regex/1.3.2/src/compile.rs:994:44 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/compile.rs:994:54 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/dfa.rs:1007:17 clippy::similar_names "binding's name is too similar to existing binding"
+regex/1.3.2/src/dfa.rs:1010:22 clippy::similar_names "binding's name is too similar to existing binding"
+regex/1.3.2/src/dfa.rs:1059:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex/1.3.2/src/dfa.rs:1060:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex/1.3.2/src/dfa.rs:1084:38 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+regex/1.3.2/src/dfa.rs:1087:38 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+regex/1.3.2/src/dfa.rs:1090:38 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+regex/1.3.2/src/dfa.rs:1093:38 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+regex/1.3.2/src/dfa.rs:1096:38 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+regex/1.3.2/src/dfa.rs:1101:38 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+regex/1.3.2/src/dfa.rs:1104:38 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+regex/1.3.2/src/dfa.rs:1107:38 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+regex/1.3.2/src/dfa.rs:1117:30 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+regex/1.3.2/src/dfa.rs:1120:47 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+regex/1.3.2/src/dfa.rs:1121:30 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+regex/1.3.2/src/dfa.rs:1129:13 clippy::doc_markdown "you should put `is_match` between ticks in the documentation"
+regex/1.3.2/src/dfa.rs:1134:13 clippy::doc_markdown "you should put `is_match` between ticks in the documentation"
+regex/1.3.2/src/dfa.rs:1185:68 clippy::doc_markdown "you should put `is_match` between ticks in the documentation"
+regex/1.3.2/src/dfa.rs:1193:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex/1.3.2/src/dfa.rs:1244:50 clippy::doc_markdown "you should put `current_state` between ticks in the documentation"
+regex/1.3.2/src/dfa.rs:1338:58 clippy::doc_markdown "you should put `STATE_DEAD` between ticks in the documentation"
+regex/1.3.2/src/dfa.rs:1339:9 clippy::doc_markdown "you should put `STATE_UNKNOWN` between ticks in the documentation"
+regex/1.3.2/src/dfa.rs:1366:25 clippy::doc_markdown "you should put `STATE_DEAD` between ticks in the documentation"
+regex/1.3.2/src/dfa.rs:1366:46 clippy::doc_markdown "you should put `STATE_UNKNOWN` between ticks in the documentation"
+regex/1.3.2/src/dfa.rs:1367:41 clippy::inline_always "you have declared `#[inline(always)]` on `start_state`. This is usually a bad idea"
+regex/1.3.2/src/dfa.rs:1380:14 clippy::identity_op "the operation is ineffective. Consider reducing it to `(empty_flags.start as u8)`"
+regex/1.3.2/src/dfa.rs:1388:15 clippy::match_on_vec_items "indexing into a vector may panic"
+regex/1.3.2/src/dfa.rs:1412:20 clippy::unused_self "unused `self` argument"
+regex/1.3.2/src/dfa.rs:1438:9 clippy::unused_self "unused `self` argument"
+regex/1.3.2/src/dfa.rs:1472:9 clippy::doc_markdown "you should put `StatePtr` between ticks in the documentation"
+regex/1.3.2/src/dfa.rs:1490:54 clippy::cast_possible_truncation "casting `i32` to `u8` may truncate the value"
+regex/1.3.2/src/dfa.rs:1490:54 clippy::cast_sign_loss "casting `i32` to `u8` may lose the sign of the value"
+regex/1.3.2/src/dfa.rs:1521:20 clippy::doc_markdown "you should put `num_byte_classes` between ticks in the documentation"
+regex/1.3.2/src/dfa.rs:1529:41 clippy::inline_always "you have declared `#[inline(always)]` on `byte_class`. This is usually a bad idea"
+regex/1.3.2/src/dfa.rs:1537:14 clippy::doc_markdown "you should put `byte_class` between ticks in the documentation"
+regex/1.3.2/src/dfa.rs:1538:41 clippy::inline_always "you have declared `#[inline(always)]` on `u8_class`. This is usually a bad idea"
+regex/1.3.2/src/dfa.rs:1562:18 clippy::doc_markdown "you should put `STATE_START` between ticks in the documentation"
+regex/1.3.2/src/dfa.rs:1614:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/dfa.rs:1651:38 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/dfa.rs:1700:17 clippy::trivially_copy_pass_by_ref "this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+regex/1.3.2/src/dfa.rs:1701:18 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex/1.3.2/src/dfa.rs:1705:19 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex/1.3.2/src/dfa.rs:1708:16 clippy::trivially_copy_pass_by_ref "this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+regex/1.3.2/src/dfa.rs:1709:18 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex/1.3.2/src/dfa.rs:1713:19 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex/1.3.2/src/dfa.rs:1716:18 clippy::trivially_copy_pass_by_ref "this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+regex/1.3.2/src/dfa.rs:1717:18 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex/1.3.2/src/dfa.rs:1721:19 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex/1.3.2/src/dfa.rs:1727:14 clippy::cast_lossless "casting `u8` to `u16` may become silently lossy if you later change the type"
+regex/1.3.2/src/dfa.rs:1732:15 clippy::trivially_copy_pass_by_ref "this argument (2 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+regex/1.3.2/src/dfa.rs:1736:22 clippy::trivially_copy_pass_by_ref "this argument (2 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+regex/1.3.2/src/dfa.rs:1741:9 clippy::match_like_matches_macro "match expression looks like `matches!` macro"
+regex/1.3.2/src/dfa.rs:1747:16 clippy::trivially_copy_pass_by_ref "this argument (2 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+regex/1.3.2/src/dfa.rs:1751:18 clippy::cast_possible_truncation "casting `u16` to `u8` may truncate the value"
+regex/1.3.2/src/dfa.rs:1815:38 clippy::cast_possible_truncation "casting `usize` to `u8` may truncate the value"
+regex/1.3.2/src/dfa.rs:1821:21 clippy::cast_lossless "casting `u32` to `u64` may become silently lossy if you later change the type"
+regex/1.3.2/src/dfa.rs:1824:5 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+regex/1.3.2/src/dfa.rs:1848:5 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
+regex/1.3.2/src/dfa.rs:1850:18 clippy::cast_sign_loss "casting `i32` to `u32` may lose the sign of the value"
+regex/1.3.2/src/dfa.rs:1857:5 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
+regex/1.3.2/src/dfa.rs:1860:17 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
+regex/1.3.2/src/dfa.rs:1867:5 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
+regex/1.3.2/src/dfa.rs:1870:19 clippy::cast_possible_truncation "casting `u32` to `u8` may truncate the value"
+regex/1.3.2/src/dfa.rs:1873:15 clippy::cast_possible_truncation "casting `u32` to `u8` may truncate the value"
+regex/1.3.2/src/dfa.rs:1876:5 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
+regex/1.3.2/src/dfa.rs:1882:26 clippy::cast_lossless "casting `u8` to `u32` may become silently lossy if you later change the type"
+regex/1.3.2/src/dfa.rs:1884:15 clippy::cast_lossless "casting `u8` to `u32` may become silently lossy if you later change the type"
+regex/1.3.2/src/dfa.rs:277:17 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
+regex/1.3.2/src/dfa.rs:277:31 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
+regex/1.3.2/src/dfa.rs:295:20 clippy::cast_possible_truncation "casting `usize` to `i32` may truncate the value on targets with 64-bit wide pointers"
+regex/1.3.2/src/dfa.rs:295:20 clippy::cast_possible_wrap "casting `usize` to `i32` may wrap around the value on targets with 32-bit wide pointers"
+regex/1.3.2/src/dfa.rs:299:21 clippy::cast_sign_loss "casting `i32` to `usize` may lose the sign of the value"
+regex/1.3.2/src/dfa.rs:34:46 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
+regex/1.3.2/src/dfa.rs:398:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+regex/1.3.2/src/dfa.rs:446:41 clippy::inline_always "you have declared `#[inline(always)]` on `forward`. This is usually a bad idea"
+regex/1.3.2/src/dfa.rs:457:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/dfa.rs:459:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/dfa.rs:460:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/dfa.rs:476:41 clippy::inline_always "you have declared `#[inline(always)]` on `reverse`. This is usually a bad idea"
+regex/1.3.2/src/dfa.rs:487:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/dfa.rs:489:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/dfa.rs:490:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/dfa.rs:506:41 clippy::inline_always "you have declared `#[inline(always)]` on `forward_many`. This is usually a bad idea"
+regex/1.3.2/src/dfa.rs:518:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/dfa.rs:520:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/dfa.rs:554:41 clippy::inline_always "you have declared `#[inline(always)]` on `exec_at`. This is usually a bad idea"
+regex/1.3.2/src/dfa.rs:555:5 clippy::too_many_lines "this function has too many lines (101/100)"
+regex/1.3.2/src/dfa.rs:58:9 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex/1.3.2/src/dfa.rs:667:21 clippy::similar_names "binding's name is too similar to existing binding"
+regex/1.3.2/src/dfa.rs:747:41 clippy::inline_always "you have declared `#[inline(always)]` on `exec_at_reverse`. This is usually a bad idea"
+regex/1.3.2/src/dfa.rs:795:21 clippy::similar_names "binding's name is too similar to existing binding"
+regex/1.3.2/src/dfa.rs:848:9 clippy::doc_markdown "you should put `next_si` between ticks in the documentation"
+regex/1.3.2/src/dfa.rs:852:41 clippy::inline_always "you have declared `#[inline(always)]` on `next_si`. This is usually a bad idea"
+regex/1.3.2/src/dfa.rs:885:12 clippy::doc_markdown "you should put `STATE_DEAD` between ticks in the documentation"
+regex/1.3.2/src/dfa.rs:889:9 clippy::doc_markdown "you should put `STATE_UNKNOWN` between ticks in the documentation"
+regex/1.3.2/src/dfa.rs:897:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex/1.3.2/src/dfa.rs:979:29 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+regex/1.3.2/src/error.rs:6:1 clippy::manual_non_exhaustive "this seems like a manual implementation of the non-exhaustive pattern"
+regex/1.3.2/src/exec.rs:1000:14 clippy::doc_markdown "you should put `captures_nfa` between ticks in the documentation"
+regex/1.3.2/src/exec.rs:100:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+regex/1.3.2/src/exec.rs:1028:5 clippy::too_many_arguments "this function has too many arguments (9/7)"
+regex/1.3.2/src/exec.rs:1039:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex/1.3.2/src/exec.rs:1144:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex/1.3.2/src/exec.rs:1179:26 clippy::match_same_arms "this `match` has identical arm bodies"
+regex/1.3.2/src/exec.rs:122:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/exec.rs:1250:41 clippy::inline_always "you have declared `#[inline(always)]` on `searcher`. This is usually a bad idea"
+regex/1.3.2/src/exec.rs:1260:41 clippy::inline_always "you have declared `#[inline(always)]` on `searcher_str`. This is usually a bad idea"
+regex/1.3.2/src/exec.rs:1270:17 clippy::doc_markdown "you should put `RegexSet` between ticks in the documentation"
+regex/1.3.2/src/exec.rs:1280:17 clippy::doc_markdown "you should put `RegexSet` between ticks in the documentation"
+regex/1.3.2/src/exec.rs:137:9 clippy::field_reassign_with_default "field assignment outside of initializer for an instance created with Default::default()"
+regex/1.3.2/src/exec.rs:142:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/exec.rs:158:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/exec.rs:168:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/exec.rs:181:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/exec.rs:195:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/exec.rs:204:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/exec.rs:210:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/exec.rs:245:62 clippy::if_same_then_else "this `if` has identical blocks"
+regex/1.3.2/src/exec.rs:251:21 clippy::if_not_else "unnecessary boolean `not` operation"
+regex/1.3.2/src/exec.rs:262:60 clippy::if_same_then_else "this `if` has identical blocks"
+regex/1.3.2/src/exec.rs:268:21 clippy::if_not_else "unnecessary boolean `not` operation"
+regex/1.3.2/src/exec.rs:278:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/exec.rs:281:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/exec.rs:286:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+regex/1.3.2/src/exec.rs:300:30 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/exec.rs:308:17 clippy::similar_names "binding's name is too similar to existing binding"
+regex/1.3.2/src/exec.rs:329:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/exec.rs:330:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/exec.rs:331:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/exec.rs:334:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/exec.rs:340:19 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/exec.rs:344:27 clippy::unused_self "unused `self` argument"
+regex/1.3.2/src/exec.rs:383:41 clippy::inline_always "you have declared `#[inline(always)]` on `shortest_match_at`. This is usually a bad idea"
+regex/1.3.2/src/exec.rs:388:41 clippy::inline_always "you have declared `#[inline(always)]` on `is_match_at`. This is usually a bad idea"
+regex/1.3.2/src/exec.rs:393:41 clippy::inline_always "you have declared `#[inline(always)]` on `find_at`. This is usually a bad idea"
+regex/1.3.2/src/exec.rs:398:41 clippy::inline_always "you have declared `#[inline(always)]` on `captures_read_at`. This is usually a bad idea"
+regex/1.3.2/src/exec.rs:425:41 clippy::inline_always "you have declared `#[inline(always)]` on `shortest_match_at`. This is usually a bad idea"
+regex/1.3.2/src/exec.rs:44:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+regex/1.3.2/src/exec.rs:473:9 clippy::doc_markdown "you should put `shortest_match(...).is_some` between ticks in the documentation"
+regex/1.3.2/src/exec.rs:474:41 clippy::inline_always "you have declared `#[inline(always)]` on `is_match_at`. This is usually a bad idea"
+regex/1.3.2/src/exec.rs:524:41 clippy::inline_always "you have declared `#[inline(always)]` on `find_at`. This is usually a bad idea"
+regex/1.3.2/src/exec.rs:52:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+regex/1.3.2/src/exec.rs:686:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex/1.3.2/src/exec.rs:727:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex/1.3.2/src/exec.rs:767:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex/1.3.2/src/exec.rs:783:41 clippy::inline_always "you have declared `#[inline(always)]` on `shortest_dfa`. This is usually a bad idea"
+regex/1.3.2/src/exec.rs:791:41 clippy::inline_always "you have declared `#[inline(always)]` on `shortest_dfa_reverse_suffix`. This is usually a bad idea"
+regex/1.3.2/src/exec.rs:823:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex/1.3.2/src/exec.rs:868:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex/1.3.2/src/exec.rs:897:31 clippy::doc_markdown "you should put `shortest_nfa(...).is_some` between ticks in the documentation"
+regex/1.3.2/src/exec.rs:899:9 clippy::doc_markdown "you should put `shortest_nfa` between ticks in the documentation"
+regex/1.3.2/src/exec.rs:905:14 clippy::doc_markdown "you should put `match_nfa` between ticks in the documentation"
+regex/1.3.2/src/exec.rs:930:14 clippy::doc_markdown "you should put `shortest_nfa` between ticks in the documentation"
+regex/1.3.2/src/exec.rs:981:14 clippy::doc_markdown "you should put `find_nfa` between ticks in the documentation"
+regex/1.3.2/src/expand.rs:170:27 clippy::trivially_copy_pass_by_ref "this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+regex/1.3.2/src/expand.rs:171:5 clippy::match_like_matches_macro "match expression looks like `matches!` macro"
+regex/1.3.2/src/expand.rs:22:13 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
+regex/1.3.2/src/expand.rs:27:23 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+regex/1.3.2/src/expand.rs:30:17 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
+regex/1.3.2/src/expand.rs:38:30 clippy::map_unwrap_or "called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead"
+regex/1.3.2/src/expand.rs:42:21 clippy::map_unwrap_or "called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead"
+regex/1.3.2/src/expand.rs:50:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+regex/1.3.2/src/expand.rs:69:23 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+regex/1.3.2/src/expand.rs:80:28 clippy::map_unwrap_or "called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead"
+regex/1.3.2/src/expand.rs:84:21 clippy::map_unwrap_or "called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead"
+regex/1.3.2/src/expand.rs:8:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+regex/1.3.2/src/input.rs:142:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+regex/1.3.2/src/input.rs:146:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/input.rs:15:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+regex/1.3.2/src/input.rs:165:31 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/input.rs:178:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex/1.3.2/src/input.rs:228:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+regex/1.3.2/src/input.rs:236:21 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/input.rs:236:33 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/input.rs:24:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/input.rs:271:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex/1.3.2/src/input.rs:29:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/input.rs:362:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/input.rs:370:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/input.rs:371:42 clippy::redundant_closure_for_method_calls "redundant closure found"
+regex/1.3.2/src/input.rs:37:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/input.rs:388:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/input.rs:42:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/input.rs:47:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/input.rs:53:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/input.rs:58:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/input.rs:63:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/lib.rs:1:null clippy::cargo_common_metadata "package `regex` is missing `package.keywords` metadata"
+regex/1.3.2/src/literal/imp.rs:101:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/literal/imp.rs:114:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/literal/imp.rs:127:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/literal/imp.rs:139:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/literal/imp.rs:144:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/literal/imp.rs:149:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/literal/imp.rs:154:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/literal/imp.rs:155:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex/1.3.2/src/literal/imp.rs:160:30 clippy::match_same_arms "this `match` has identical arm bodies"
+regex/1.3.2/src/literal/imp.rs:167:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/literal/imp.rs:168:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex/1.3.2/src/literal/imp.rs:211:20 clippy::redundant_else "redundant else block"
+regex/1.3.2/src/literal/imp.rs:276:50 clippy::match_same_arms "this `match` has identical arm bodies"
+regex/1.3.2/src/literal/imp.rs:342:41 clippy::inline_always "you have declared `#[inline(always)]` on `find`. This is usually a bad idea"
+regex/1.3.2/src/literal/imp.rs:435:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/literal/imp.rs:436:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/literal/imp.rs:437:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/literal/imp.rs:438:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/literal/imp.rs:439:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/literal/imp.rs:440:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/literal/imp.rs:455:41 clippy::inline_always "you have declared `#[inline(always)]` on `find`. This is usually a bad idea"
+regex/1.3.2/src/literal/imp.rs:46:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/literal/imp.rs:481:41 clippy::inline_always "you have declared `#[inline(always)]` on `is_suffix`. This is usually a bad idea"
+regex/1.3.2/src/literal/imp.rs:51:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/literal/imp.rs:579:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/literal/imp.rs:57:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/literal/imp.rs:580:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/literal/imp.rs:583:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/literal/imp.rs:602:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+regex/1.3.2/src/literal/imp.rs:622:24 clippy::redundant_else "redundant else block"
+regex/1.3.2/src/literal/imp.rs:62:18 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+regex/1.3.2/src/literal/imp.rs:637:24 clippy::redundant_else "redundant else block"
+regex/1.3.2/src/literal/imp.rs:648:9 clippy::needless_return "unneeded `return` statement"
+regex/1.3.2/src/literal/imp.rs:651:44 clippy::doc_markdown "you should put `BoyerMooreSearch` between ticks in the documentation"
+regex/1.3.2/src/literal/imp.rs:65:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/literal/imp.rs:68:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/literal/imp.rs:783:32 clippy::redundant_else "redundant else block"
+regex/1.3.2/src/literal/imp.rs:786:42 clippy::manual_saturating_arithmetic "manual saturating arithmetic"
+regex/1.3.2/src/literal/imp.rs:78:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/literal/imp.rs:84:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/literal/imp.rs:850:20 clippy::unreadable_literal "long literal lacking separators"
+regex/1.3.2/src/literal/imp.rs:85:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex/1.3.2/src/pikevm.rs:103:15 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/pikevm.rs:103:52 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/pikevm.rs:114:5 clippy::too_many_arguments "this function has too many arguments (8/7)"
+regex/1.3.2/src/pikevm.rs:117:13 clippy::similar_names "binding's name is too similar to existing binding"
+regex/1.3.2/src/pikevm.rs:124:17 clippy::similar_names "binding's name is too similar to existing binding"
+regex/1.3.2/src/pikevm.rs:220:9 clippy::doc_markdown "you should put `thread_caps` between ticks in the documentation"
+regex/1.3.2/src/pikevm.rs:222:16 clippy::doc_markdown "you should put `at_next` between ticks in the documentation"
+regex/1.3.2/src/pikevm.rs:223:9 clippy::doc_markdown "you should put `at_next` between ticks in the documentation"
+regex/1.3.2/src/pikevm.rs:224:5 clippy::too_many_arguments "this function has too many arguments (8/7)"
+regex/1.3.2/src/pikevm.rs:234:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex/1.3.2/src/pikevm.rs:303:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex/1.3.2/src/pikevm.rs:331:29 clippy::mut_mut "this expression mutably borrows a mutable reference. Consider reborrowing"
+regex/1.3.2/src/pikevm.rs:88:5 clippy::too_many_arguments "this function has too many arguments (8/7)"
+regex/1.3.2/src/prog.rs:102:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/prog.rs:113:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/prog.rs:120:9 clippy::match_like_matches_macro "match expression looks like `matches!` macro"
+regex/1.3.2/src/prog.rs:128:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/prog.rs:134:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/prog.rs:141:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/prog.rs:147:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/prog.rs:164:41 clippy::inline_always "you have declared `#[inline(always)]` on `deref`. This is usually a bad idea"
+regex/1.3.2/src/prog.rs:172:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex/1.3.2/src/prog.rs:18:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+regex/1.3.2/src/prog.rs:236:13 clippy::write_with_newline "using `write!()` with a format string that ends in a single newline"
+regex/1.3.2/src/prog.rs:300:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/prog.rs:301:9 clippy::match_like_matches_macro "match expression looks like `matches!` macro"
+regex/1.3.2/src/prog.rs:382:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/prog.rs:409:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/prog.rs:80:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/prog.rs:80:5 clippy::new_without_default "you should consider adding a `Default` implementation for `prog::Program`"
+regex/1.3.2/src/re_builder.rs:267:17 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+regex/1.3.2/src/re_builder.rs:267:17 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+regex/1.3.2/src/re_builder.rs:4:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+regex/1.3.2/src/re_builder.rs:57:17 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/re_builder.rs:57:17 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/re_builder.rs:68:17 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+regex/1.3.2/src/re_builder.rs:68:17 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+regex/1.3.2/src/re_bytes.rs:1017:9 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
+regex/1.3.2/src/re_bytes.rs:1039:9 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
+regex/1.3.2/src/re_bytes.rs:1093:5 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
+regex/1.3.2/src/re_bytes.rs:1118:5 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
+regex/1.3.2/src/re_bytes.rs:1133:5 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
+regex/1.3.2/src/re_bytes.rs:118:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+regex/1.3.2/src/re_bytes.rs:256:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/re_bytes.rs:29:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/re_bytes.rs:35:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/re_bytes.rs:42:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/re_bytes.rs:48:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/re_bytes.rs:558:29 clippy::doc_markdown "you should put `shortest_match` between ticks in the documentation"
+regex/1.3.2/src/re_bytes.rs:55:33 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/re_bytes.rs:55:47 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/re_bytes.rs:572:29 clippy::doc_markdown "you should put `is_match` between ticks in the documentation"
+regex/1.3.2/src/re_bytes.rs:720:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/re_bytes.rs:817:5 clippy::doc_markdown "you should put `CaptureLocations` between ticks in the documentation"
+regex/1.3.2/src/re_bytes.rs:843:1 clippy::len_without_is_empty "item `re_bytes::CaptureLocations` has a public `len` method but no corresponding `is_empty` method"
+regex/1.3.2/src/re_bytes.rs:849:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/re_bytes.rs:858:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/re_bytes.rs:869:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/re_bytes.rs:891:1 clippy::len_without_is_empty "item `re_bytes::Captures<'t>` has a public `len` method but no corresponding `is_empty` method"
+regex/1.3.2/src/re_bytes.rs:911:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/re_bytes.rs:917:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/re_bytes.rs:926:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/re_bytes.rs:955:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/re_set.rs:179:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/re_set.rs:179:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/re_set.rs:251:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/re_set.rs:251:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/re_set.rs:263:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/re_set.rs:263:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/re_set.rs:268:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/re_set.rs:268:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/re_set.rs:277:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/re_set.rs:277:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/re_set.rs:94:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+regex/1.3.2/src/re_set.rs:94:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+regex/1.3.2/src/re_trait.rs:136:29 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/re_unicode.rs:1019:9 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
+regex/1.3.2/src/re_unicode.rs:1041:9 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
+regex/1.3.2/src/re_unicode.rs:1088:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/re_unicode.rs:1135:5 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
+regex/1.3.2/src/re_unicode.rs:1160:5 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
+regex/1.3.2/src/re_unicode.rs:174:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+regex/1.3.2/src/re_unicode.rs:21:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+regex/1.3.2/src/re_unicode.rs:313:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/re_unicode.rs:38:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/re_unicode.rs:44:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/re_unicode.rs:51:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/re_unicode.rs:57:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/re_unicode.rs:617:29 clippy::doc_markdown "you should put `shortest_match` between ticks in the documentation"
+regex/1.3.2/src/re_unicode.rs:631:29 clippy::doc_markdown "you should put `is_match` between ticks in the documentation"
+regex/1.3.2/src/re_unicode.rs:64:33 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/re_unicode.rs:64:47 clippy::redundant_field_names "redundant field names in struct initialization"
+regex/1.3.2/src/re_unicode.rs:834:5 clippy::doc_markdown "you should put `CaptureLocations` between ticks in the documentation"
+regex/1.3.2/src/re_unicode.rs:860:1 clippy::len_without_is_empty "item `re_unicode::CaptureLocations` has a public `len` method but no corresponding `is_empty` method"
+regex/1.3.2/src/re_unicode.rs:866:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/re_unicode.rs:875:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/re_unicode.rs:886:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/re_unicode.rs:908:1 clippy::len_without_is_empty "item `re_unicode::Captures<'t>` has a public `len` method but no corresponding `is_empty` method"
+regex/1.3.2/src/re_unicode.rs:928:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/re_unicode.rs:934:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/re_unicode.rs:943:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/re_unicode.rs:972:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/sparse.rs:10:37 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
+regex/1.3.2/src/sparse.rs:15:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+regex/1.3.2/src/utf8.rs:100:16 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex/1.3.2/src/utf8.rs:103:16 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex/1.3.2/src/utf8.rs:106:22 clippy::cast_lossless "casting `u8` to `u32` may become silently lossy if you later change the type"
+regex/1.3.2/src/utf8.rs:107:19 clippy::cast_lossless "casting `u8` to `u32` may become silently lossy if you later change the type"
+regex/1.3.2/src/utf8.rs:108:19 clippy::cast_lossless "casting `u8` to `u32` may become silently lossy if you later change the type"
+regex/1.3.2/src/utf8.rs:109:19 clippy::cast_lossless "casting `u8` to `u32` may become silently lossy if you later change the type"
+regex/1.3.2/src/utf8.rs:111:27 clippy::unreadable_literal "long literal lacking separators"
+regex/1.3.2/src/utf8.rs:121:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+regex/1.3.2/src/utf8.rs:143:24 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex/1.3.2/src/utf8.rs:143:9 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex/1.3.2/src/utf8.rs:23:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+regex/1.3.2/src/utf8.rs:30:20 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex/1.3.2/src/utf8.rs:51:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+regex/1.3.2/src/utf8.rs:58:23 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex/1.3.2/src/utf8.rs:58:9 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex/1.3.2/src/utf8.rs:63:16 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex/1.3.2/src/utf8.rs:66:22 clippy::cast_lossless "casting `u8` to `u32` may become silently lossy if you later change the type"
+regex/1.3.2/src/utf8.rs:66:54 clippy::cast_lossless "casting `u8` to `u32` may become silently lossy if you later change the type"
+regex/1.3.2/src/utf8.rs:77:16 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex/1.3.2/src/utf8.rs:80:16 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex/1.3.2/src/utf8.rs:83:22 clippy::cast_lossless "casting `u8` to `u32` may become silently lossy if you later change the type"
+regex/1.3.2/src/utf8.rs:84:19 clippy::cast_lossless "casting `u8` to `u32` may become silently lossy if you later change the type"
+regex/1.3.2/src/utf8.rs:85:19 clippy::cast_lossless "casting `u8` to `u32` may become silently lossy if you later change the type"
+regex/1.3.2/src/utf8.rs:92:23 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex/1.3.2/src/utf8.rs:92:9 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex/1.3.2/src/utf8.rs:97:16 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+ripgrep/12.1.1//home/matthias/.rustup/toolchains/nightly-2020-12-20-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/std/src/macros.rs:14:27 clippy::match_same_arms "this `match` has identical arm bodies"
+ripgrep/12.1.1//home/matthias/.rustup/toolchains/nightly-2020-12-20-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/std/src/macros.rs:14:27 clippy::match_same_arms "this `match` has identical arm bodies"
+ripgrep/12.1.1//home/matthias/.rustup/toolchains/nightly-2020-12-20-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/std/src/macros.rs:14:27 clippy::match_same_arms "this `match` has identical arm bodies"
+ripgrep/12.1.1//home/matthias/.rustup/toolchains/nightly-2020-12-20-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/std/src/macros.rs:14:27 clippy::match_same_arms "this `match` has identical arm bodies"
+ripgrep/12.1.1/build.rs:133:19 clippy::option_as_ref_deref "called `.as_ref().map(|x| &**x)` on an Option value. This can be done more directly by calling `githash.as_deref()` instead"
+ripgrep/12.1.1/build.rs:18:18 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+ripgrep/12.1.1/build.rs:225:14 clippy::redundant_closure_for_method_calls "redundant closure found"
+ripgrep/12.1.1/build.rs:92:19 clippy::option_as_ref_deref "called `.as_ref().map(|x| &**x)` on an Option value. This can be done more directly by calling `githash.as_deref()` instead"
+ripgrep/12.1.1/crates/core/app.rs:1408:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+ripgrep/12.1.1/crates/core/app.rs:1408:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+ripgrep/12.1.1/crates/core/app.rs:1409:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+ripgrep/12.1.1/crates/core/app.rs:1409:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+ripgrep/12.1.1/crates/core/app.rs:152:32 clippy::doc_markdown "you should put `clap::Arg` between ticks in the documentation"
+ripgrep/12.1.1/crates/core/app.rs:152:32 clippy::doc_markdown "you should put `clap::Arg` between ticks in the documentation"
+ripgrep/12.1.1/crates/core/app.rs:156:39 clippy::doc_markdown "you should put `clap::Arg` between ticks in the documentation"
+ripgrep/12.1.1/crates/core/app.rs:156:39 clippy::doc_markdown "you should put `clap::Arg` between ticks in the documentation"
+ripgrep/12.1.1/crates/core/app.rs:156:5 clippy::doc_markdown "you should put `RGArg` between ticks in the documentation"
+ripgrep/12.1.1/crates/core/app.rs:156:5 clippy::doc_markdown "you should put `RGArg` between ticks in the documentation"
+ripgrep/12.1.1/crates/core/app.rs:1668:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+ripgrep/12.1.1/crates/core/app.rs:1668:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+ripgrep/12.1.1/crates/core/app.rs:1669:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+ripgrep/12.1.1/crates/core/app.rs:1669:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+ripgrep/12.1.1/crates/core/app.rs:1821:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+ripgrep/12.1.1/crates/core/app.rs:1821:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+ripgrep/12.1.1/crates/core/app.rs:1822:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+ripgrep/12.1.1/crates/core/app.rs:1822:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+ripgrep/12.1.1/crates/core/app.rs:2999:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+ripgrep/12.1.1/crates/core/app.rs:2999:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+ripgrep/12.1.1/crates/core/app.rs:3000:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+ripgrep/12.1.1/crates/core/app.rs:3000:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+ripgrep/12.1.1/crates/core/app.rs:367:54 clippy::match_same_arms "this `match` has identical arm bodies"
+ripgrep/12.1.1/crates/core/app.rs:367:54 clippy::match_same_arms "this `match` has identical arm bodies"
+ripgrep/12.1.1/crates/core/app.rs:414:59 clippy::match_same_arms "this `match` has identical arm bodies"
+ripgrep/12.1.1/crates/core/app.rs:414:59 clippy::match_same_arms "this `match` has identical arm bodies"
+ripgrep/12.1.1/crates/core/app.rs:417:57 clippy::match_same_arms "this `match` has identical arm bodies"
+ripgrep/12.1.1/crates/core/app.rs:417:57 clippy::match_same_arms "this `match` has identical arm bodies"
+ripgrep/12.1.1/crates/core/app.rs:417:57 clippy::match_same_arms "this `match` has identical arm bodies"
+ripgrep/12.1.1/crates/core/app.rs:417:57 clippy::match_same_arms "this `match` has identical arm bodies"
+ripgrep/12.1.1/crates/core/app.rs:75:9 clippy::doc_markdown "you should put `RIPGREP_BUILD_GIT_HASH` between ticks in the documentation"
+ripgrep/12.1.1/crates/core/app.rs:75:9 clippy::doc_markdown "you should put `RIPGREP_BUILD_GIT_HASH` between ticks in the documentation"
+ripgrep/12.1.1/crates/core/app.rs:87:5 clippy::if_not_else "unnecessary boolean `not` operation"
+ripgrep/12.1.1/crates/core/app.rs:87:5 clippy::if_not_else "unnecessary boolean `not` operation"
+ripgrep/12.1.1/crates/core/args.rs:1143:22 clippy::unused_self "unused `self` argument"
+ripgrep/12.1.1/crates/core/args.rs:11:1 clippy::single_component_path_imports "this import is redundant"
+ripgrep/12.1.1/crates/core/args.rs:1209:74 clippy::if_same_then_else "this `if` has identical blocks"
+ripgrep/12.1.1/crates/core/args.rs:1209:74 clippy::if_same_then_else "this `if` has identical blocks"
+ripgrep/12.1.1/crates/core/args.rs:1282:13 clippy::similar_names "binding's name is too similar to existing binding"
+ripgrep/12.1.1/crates/core/args.rs:1430:22 clippy::unused_self "unused `self` argument"
+ripgrep/12.1.1/crates/core/args.rs:1438:21 clippy::doc_markdown "you should put `OsStr` between ticks in the documentation"
+ripgrep/12.1.1/crates/core/args.rs:1520:44 clippy::redundant_closure_for_method_calls "redundant closure found"
+ripgrep/12.1.1/crates/core/args.rs:1524:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+ripgrep/12.1.1/crates/core/args.rs:1635:14 clippy::doc_markdown "you should put `values_of_lossy` between ticks in the documentation"
+ripgrep/12.1.1/crates/core/args.rs:1693:41 clippy::redundant_closure_for_method_calls "redundant closure found"
+ripgrep/12.1.1/crates/core/args.rs:1770:17 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
+ripgrep/12.1.1/crates/core/args.rs:287:13 clippy::similar_names "binding's name is too similar to existing binding"
+ripgrep/12.1.1/crates/core/args.rs:33:1 clippy::single_component_path_imports "this import is redundant"
+ripgrep/12.1.1/crates/core/args.rs:34:1 clippy::single_component_path_imports "this import is redundant"
+ripgrep/12.1.1/crates/core/args.rs:35:1 clippy::single_component_path_imports "this import is redundant"
+ripgrep/12.1.1/crates/core/args.rs:410:14 clippy::trivially_copy_pass_by_ref "this argument (2 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+ripgrep/12.1.1/crates/core/args.rs:475:18 clippy::match_same_arms "this `match` has identical arm bodies"
+ripgrep/12.1.1/crates/core/args.rs:512:19 clippy::doc_markdown "you should put `ArgMatches` between ticks in the documentation"
+ripgrep/12.1.1/crates/core/args.rs:549:16 clippy::wrong_self_convention "methods called `to_*` usually take self by reference; consider choosing a less ambiguous name"
+ripgrep/12.1.1/crates/core/args.rs:76:18 clippy::trivially_copy_pass_by_ref "this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+ripgrep/12.1.1/crates/core/args.rs:77:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+ripgrep/12.1.1/crates/core/args.rs:923:42 clippy::doc_markdown "you should put `BinaryDetection::quit` between ticks in the documentation"
+ripgrep/12.1.1/crates/core/config.rs:13:1 clippy::single_component_path_imports "this import is redundant"
+ripgrep/12.1.1/crates/core/config.rs:58:6 clippy::type_complexity "very complex type used. Consider factoring parts into `type` definitions"
+ripgrep/12.1.1/crates/core/config.rs:79:6 clippy::type_complexity "very complex type used. Consider factoring parts into `type` definitions"
+ripgrep/12.1.1/crates/core/logger.rs:11:30 clippy::doc_markdown "you should put `max_level` between ticks in the documentation"
+ripgrep/12.1.1/crates/core/logger.rs:15:16 clippy::redundant_static_lifetimes "constants have by default a `'static` lifetime"
+ripgrep/12.1.1/crates/core/main.rs:55:19 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+ripgrep/12.1.1/crates/core/main.rs:56:9 clippy::enum_glob_use "usage of wildcard import for enum variants"
+ripgrep/12.1.1/crates/core/messages.rs:46:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+ripgrep/12.1.1/crates/core/messages.rs:51:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+ripgrep/12.1.1/crates/core/messages.rs:62:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+ripgrep/12.1.1/crates/core/path_printer.rs:27:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+ripgrep/12.1.1/crates/core/path_printer.rs:89:9 clippy::if_not_else "unnecessary boolean `not` operation"
+ripgrep/12.1.1/crates/core/search.rs:185:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+ripgrep/12.1.1/crates/core/search.rs:292:9 clippy::write_with_newline "using `write!()` with a format string that ends in a single newline"
+ripgrep/12.1.1/crates/core/search.rs:311:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+ripgrep/12.1.1/crates/core/search.rs:377:12 clippy::nonminimal_bool "this boolean expression can be simplified"
+ripgrep/12.1.1/crates/core/search.rs:423:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+ripgrep/12.1.1/crates/core/search.rs:447:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+ripgrep/12.1.1/crates/core/search.rs:472:24 clippy::map_clone "you are using an explicit closure for cloning elements"
+ripgrep/12.1.1/crates/core/search.rs:472:41 clippy::redundant_closure_for_method_calls "redundant closure found"
+ripgrep/12.1.1/crates/core/search.rs:480:24 clippy::map_clone "you are using an explicit closure for cloning elements"
+ripgrep/12.1.1/crates/core/search.rs:480:41 clippy::redundant_closure_for_method_calls "redundant closure found"
+ripgrep/12.1.1/crates/core/search.rs:49:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+ripgrep/12.1.1/crates/core/search.rs:509:24 clippy::map_clone "you are using an explicit closure for cloning elements"
+ripgrep/12.1.1/crates/core/search.rs:509:41 clippy::redundant_closure_for_method_calls "redundant closure found"
+ripgrep/12.1.1/crates/core/search.rs:517:24 clippy::map_clone "you are using an explicit closure for cloning elements"
+ripgrep/12.1.1/crates/core/search.rs:517:41 clippy::redundant_closure_for_method_calls "redundant closure found"
+ripgrep/12.1.1/crates/core/search.rs:533:36 clippy::cast_lossless "casting `u32` to `f64` may become silently lossy if you later change the type"
+ripgrep/12.1.1/crates/core/search.rs:533:5 clippy::cast_precision_loss "casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+ripgrep/12.1.1/crates/core/subject.rs:20:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+ripgrep/12.1.1/crates/core/subject.rs:4:1 clippy::single_component_path_imports "this import is redundant"
+syn/1.0.54/build.rs:1:null clippy::cargo_common_metadata "package `syn` is missing `package.keywords` metadata"
+syn/1.0.54/build.rs:1:null clippy::multiple_crate_versions "could not read cargo metadata: failed to run `cargo metadata`:  Downloading crates ...\n  Downloaded syn-test-suite v0.0.0\nerror: failed to verify the checksum of `syn-test-suite v0.0.0`"
+syn/1.0.54/src/lib.rs:1:null clippy::cargo_common_metadata "package `syn` is missing `package.keywords` metadata"
+syn/1.0.54/src/lib.rs:1:null clippy::multiple_crate_versions "could not read cargo metadata: failed to run `cargo metadata`:  Downloading crates ...\n  Downloaded syn-test-suite v0.0.0\nerror: failed to verify the checksum of `syn-test-suite v0.0.0`"
+syn/1.0.54/src/lit.rs:1397:40 clippy::redundant_else "redundant else block"
+syn/1.0.54/src/lit.rs:1405:28 clippy::redundant_else "redundant else block"
+syn/1.0.54/src/lit.rs:1485:32 clippy::redundant_else "redundant else block"
+unicode-xid/0.2.1/src/lib.rs:1:null clippy::cargo_common_metadata "package `unicode-xid` is missing `package.categories` metadata"
+unicode-xid/0.2.1/src/lib.rs:57:64 clippy::doc_markdown "you should put `XID_Start` between ticks in the documentation"
+unicode-xid/0.2.1/src/lib.rs:60:10 clippy::doc_markdown "you should put `XID_Start` between ticks in the documentation"
+unicode-xid/0.2.1/src/lib.rs:62:27 clippy::doc_markdown "you should put `ID_Start` between ticks in the documentation"
+unicode-xid/0.2.1/src/lib.rs:62:67 clippy::doc_markdown "you should put `NFKx` between ticks in the documentation"
+unicode-xid/0.2.1/src/lib.rs:63:21 clippy::wrong_self_convention "methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name"
+unicode-xid/0.2.1/src/lib.rs:65:61 clippy::doc_markdown "you should put `XID_Continue` between ticks in the documentation"
+unicode-xid/0.2.1/src/lib.rs:68:10 clippy::doc_markdown "you should put `XID_Continue` between ticks in the documentation"
+unicode-xid/0.2.1/src/lib.rs:70:28 clippy::doc_markdown "you should put `ID_Continue` between ticks in the documentation"
+unicode-xid/0.2.1/src/lib.rs:70:72 clippy::doc_markdown "you should put `NFKx` between ticks in the documentation"
+unicode-xid/0.2.1/src/lib.rs:71:24 clippy::wrong_self_convention "methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name"
+xsv/0.13.0/src/cmd/cat.rs:101:34 clippy::redundant_closure_for_method_calls "redundant closure found"
+xsv/0.13.0/src/cmd/cat.rs:42:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+xsv/0.13.0/src/cmd/cat.rs:53:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv/0.13.0/src/cmd/cat.rs:7:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv/0.13.0/src/cmd/count.rs:32:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv/0.13.0/src/cmd/count.rs:38:9 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+xsv/0.13.0/src/cmd/count.rs:42:33 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+xsv/0.13.0/src/cmd/count.rs:50:5 clippy::unit_arg "passing a unit value to a function"
+xsv/0.13.0/src/cmd/count.rs:7:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv/0.13.0/src/cmd/fixlengths.rs:45:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv/0.13.0/src/cmd/fixlengths.rs:50:18 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+xsv/0.13.0/src/cmd/fixlengths.rs:62:30 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+xsv/0.13.0/src/cmd/fixlengths.rs:9:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv/0.13.0/src/cmd/flatten.rs:10:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv/0.13.0/src/cmd/flatten.rs:51:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv/0.13.0/src/cmd/fmt.rs:50:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv/0.13.0/src/cmd/fmt.rs:55:13 clippy::similar_names "binding's name is too similar to existing binding"
+xsv/0.13.0/src/cmd/fmt.rs:7:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv/0.13.0/src/cmd/frequency.rs:148:43 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
+xsv/0.13.0/src/cmd/frequency.rs:149:43 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
+xsv/0.13.0/src/cmd/frequency.rs:15:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv/0.13.0/src/cmd/frequency.rs:169:13 clippy::similar_names "binding's name is too similar to existing binding"
+xsv/0.13.0/src/cmd/frequency.rs:176:17 clippy::if_not_else "unnecessary boolean `not` operation"
+xsv/0.13.0/src/cmd/frequency.rs:178:24 clippy::collapsible_if "this `else { if .. }` block can be collapsed"
+xsv/0.13.0/src/cmd/frequency.rs:77:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv/0.13.0/src/cmd/frequency.rs:93:31 clippy::explicit_into_iter_loop "it is more concise to loop over containers instead of using explicit iteration methods"
+xsv/0.13.0/src/cmd/headers.rs:43:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv/0.13.0/src/cmd/headers.rs:49:17 clippy::explicit_into_iter_loop "it is more concise to loop over containers instead of using explicit iteration methods"
+xsv/0.13.0/src/cmd/headers.rs:9:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv/0.13.0/src/cmd/index.rs:11:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv/0.13.0/src/cmd/index.rs:45:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv/0.13.0/src/cmd/input.rs:42:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv/0.13.0/src/cmd/input.rs:47:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv/0.13.0/src/cmd/input.rs:7:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv/0.13.0/src/cmd/join.rs:17:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv/0.13.0/src/cmd/join.rs:194:29 clippy::similar_names "binding's name is too similar to existing binding"
+xsv/0.13.0/src/cmd/join.rs:224:22 clippy::similar_names "binding's name is too similar to existing binding"
+xsv/0.13.0/src/cmd/join.rs:293:14 clippy::similar_names "binding's name is too similar to existing binding"
+xsv/0.13.0/src/cmd/join.rs:293:20 clippy::similar_names "binding's name is too similar to existing binding"
+xsv/0.13.0/src/cmd/join.rs:297:13 clippy::redundant_field_names "redundant field names in struct initialization"
+xsv/0.13.0/src/cmd/join.rs:298:13 clippy::redundant_field_names "redundant field names in struct initialization"
+xsv/0.13.0/src/cmd/join.rs:299:13 clippy::redundant_field_names "redundant field names in struct initialization"
+xsv/0.13.0/src/cmd/join.rs:300:13 clippy::redundant_field_names "redundant field names in struct initialization"
+xsv/0.13.0/src/cmd/join.rs:308:9 clippy::unused_self "unused `self` argument"
+xsv/0.13.0/src/cmd/join.rs:342:38 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+xsv/0.13.0/src/cmd/join.rs:342:46 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+xsv/0.13.0/src/cmd/join.rs:347:9 clippy::if_not_else "unnecessary boolean `not` operation"
+xsv/0.13.0/src/cmd/join.rs:372:44 clippy::redundant_closure_for_method_calls "redundant closure found"
+xsv/0.13.0/src/cmd/join.rs:375:33 clippy::similar_names "binding's name is too similar to existing binding"
+xsv/0.13.0/src/cmd/join.rs:392:13 clippy::redundant_field_names "redundant field names in struct initialization"
+xsv/0.13.0/src/cmd/join.rs:403:29 clippy::explicit_into_iter_loop "it is more concise to loop over containers instead of using explicit iteration methods"
+xsv/0.13.0/src/cmd/join.rs:426:13 clippy::if_not_else "unnecessary boolean `not` operation"
+xsv/0.13.0/src/cmd/join.rs:77:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+xsv/0.13.0/src/cmd/join.rs:94:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv/0.13.0/src/cmd/partition.rs:105:22 clippy::similar_names "binding's name is too similar to existing binding"
+xsv/0.13.0/src/cmd/partition.rs:139:13 clippy::redundant_field_names "redundant field names in struct initialization"
+xsv/0.13.0/src/cmd/partition.rs:15:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv/0.13.0/src/cmd/partition.rs:169:9 clippy::if_not_else "unnecessary boolean `not` operation"
+xsv/0.13.0/src/cmd/partition.rs:56:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv/0.13.0/src/cmd/partition.rs:77:9 clippy::unused_self "unused `self` argument"
+xsv/0.13.0/src/cmd/sample.rs:105:44 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
+xsv/0.13.0/src/cmd/sample.rs:115:21 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
+xsv/0.13.0/src/cmd/sample.rs:11:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv/0.13.0/src/cmd/sample.rs:51:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv/0.13.0/src/cmd/sample.rs:58:19 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+xsv/0.13.0/src/cmd/sample.rs:69:9 clippy::match_wildcard_for_single_variants "wildcard match will miss any future added variants"
+xsv/0.13.0/src/cmd/sample.rs:75:16 clippy::explicit_into_iter_loop "it is more concise to loop over containers instead of using explicit iteration methods"
+xsv/0.13.0/src/cmd/sample.rs:91:42 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
+xsv/0.13.0/src/cmd/sample.rs:92:43 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
+xsv/0.13.0/src/cmd/search.rs:51:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv/0.13.0/src/cmd/search.rs:9:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv/0.13.0/src/cmd/select.rs:60:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv/0.13.0/src/cmd/select.rs:8:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv/0.13.0/src/cmd/slice.rs:57:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv/0.13.0/src/cmd/slice.rs:9:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv/0.13.0/src/cmd/sort.rs:11:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv/0.13.0/src/cmd/sort.rs:138:47 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+xsv/0.13.0/src/cmd/sort.rs:139:51 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+xsv/0.13.0/src/cmd/sort.rs:48:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv/0.13.0/src/cmd/sort.rs:91:14 clippy::explicit_into_iter_loop "it is more concise to loop over containers instead of using explicit iteration methods"
+xsv/0.13.0/src/cmd/split.rs:14:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv/0.13.0/src/cmd/split.rs:61:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv/0.13.0/src/cmd/split.rs:94:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+xsv/0.13.0/src/cmd/split.rs:96:14 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+xsv/0.13.0/src/cmd/split.rs:99:13 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
+xsv/0.13.0/src/cmd/stats.rs:110:36 clippy::redundant_closure_for_method_calls "redundant closure found"
+xsv/0.13.0/src/cmd/stats.rs:127:14 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+xsv/0.13.0/src/cmd/stats.rs:138:43 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
+xsv/0.13.0/src/cmd/stats.rs:139:43 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
+xsv/0.13.0/src/cmd/stats.rs:162:25 clippy::explicit_into_iter_loop "it is more concise to loop over containers instead of using explicit iteration methods"
+xsv/0.13.0/src/cmd/stats.rs:22:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv/0.13.0/src/cmd/stats.rs:231:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+xsv/0.13.0/src/cmd/stats.rs:262:35 clippy::default_trait_access "calling `cmd::stats::TypedSum::default()` is more clear than this expression"
+xsv/0.13.0/src/cmd/stats.rs:263:40 clippy::default_trait_access "calling `cmd::stats::TypedMinMax::default()` is more clear than this expression"
+xsv/0.13.0/src/cmd/stats.rs:264:39 clippy::default_trait_access "calling `stats::OnlineStats::default()` is more clear than this expression"
+xsv/0.13.0/src/cmd/stats.rs:265:58 clippy::default_trait_access "calling `stats::Unsorted::default()` is more clear than this expression"
+xsv/0.13.0/src/cmd/stats.rs:266:41 clippy::default_trait_access "calling `stats::Unsorted::default()` is more clear than this expression"
+xsv/0.13.0/src/cmd/stats.rs:268:18 clippy::default_trait_access "calling `cmd::stats::FieldType::default()` is more clear than this expression"
+xsv/0.13.0/src/cmd/stats.rs:269:13 clippy::redundant_field_names "redundant field names in struct initialization"
+xsv/0.13.0/src/cmd/stats.rs:270:13 clippy::redundant_field_names "redundant field names in struct initialization"
+xsv/0.13.0/src/cmd/stats.rs:271:13 clippy::redundant_field_names "redundant field names in struct initialization"
+xsv/0.13.0/src/cmd/stats.rs:272:13 clippy::redundant_field_names "redundant field names in struct initialization"
+xsv/0.13.0/src/cmd/stats.rs:273:13 clippy::redundant_field_names "redundant field names in struct initialization"
+xsv/0.13.0/src/cmd/stats.rs:274:13 clippy::redundant_field_names "redundant field names in struct initialization"
+xsv/0.13.0/src/cmd/stats.rs:283:9 clippy::option_map_unit_fn "called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`"
+xsv/0.13.0/src/cmd/stats.rs:284:9 clippy::option_map_unit_fn "called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`"
+xsv/0.13.0/src/cmd/stats.rs:285:9 clippy::option_map_unit_fn "called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`"
+xsv/0.13.0/src/cmd/stats.rs:290:21 clippy::option_map_unit_fn "called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`"
+xsv/0.13.0/src/cmd/stats.rs:293:25 clippy::match_same_arms "this `match` has identical arm bodies"
+xsv/0.13.0/src/cmd/stats.rs:297:25 clippy::option_map_unit_fn "called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`"
+xsv/0.13.0/src/cmd/stats.rs:301:21 clippy::option_map_unit_fn "called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`"
+xsv/0.13.0/src/cmd/stats.rs:302:21 clippy::option_map_unit_fn "called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`"
+xsv/0.13.0/src/cmd/stats.rs:308:18 clippy::wrong_self_convention "methods called `to_*` usually take self by reference; consider choosing a less ambiguous name"
+xsv/0.13.0/src/cmd/stats.rs:318:9 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+xsv/0.13.0/src/cmd/stats.rs:322:45 clippy::redundant_closure_for_method_calls "redundant closure found"
+xsv/0.13.0/src/cmd/stats.rs:322:9 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+xsv/0.13.0/src/cmd/stats.rs:327:9 clippy::if_not_else "unnecessary boolean `not` operation"
+xsv/0.13.0/src/cmd/stats.rs:330:13 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+xsv/0.13.0/src/cmd/stats.rs:338:45 clippy::redundant_closure_for_method_calls "redundant closure found"
+xsv/0.13.0/src/cmd/stats.rs:402:16 clippy::redundant_pattern_matching "redundant pattern matching, consider using `is_ok()`"
+xsv/0.13.0/src/cmd/stats.rs:403:16 clippy::redundant_pattern_matching "redundant pattern matching, consider using `is_ok()`"
+xsv/0.13.0/src/cmd/stats.rs:407:18 clippy::trivially_copy_pass_by_ref "this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+xsv/0.13.0/src/cmd/stats.rs:411:16 clippy::trivially_copy_pass_by_ref "this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+xsv/0.13.0/src/cmd/stats.rs:427:56 clippy::match_same_arms "this `match` has identical arm bodies"
+xsv/0.13.0/src/cmd/stats.rs:429:56 clippy::match_same_arms "this `match` has identical arm bodies"
+xsv/0.13.0/src/cmd/stats.rs:430:60 clippy::match_same_arms "this `match` has identical arm bodies"
+xsv/0.13.0/src/cmd/stats.rs:430:60 clippy::match_same_arms "this `match` has identical arm bodies"
+xsv/0.13.0/src/cmd/stats.rs:454:5 clippy::doc_markdown "you should put `TypedSum` between ticks in the documentation"
+xsv/0.13.0/src/cmd/stats.rs:473:43 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+xsv/0.13.0/src/cmd/stats.rs:504:56 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+xsv/0.13.0/src/cmd/stats.rs:505:51 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+xsv/0.13.0/src/cmd/stats.rs:511:5 clippy::doc_markdown "you should put `TypedMinMax` between ticks in the documentation"
+xsv/0.13.0/src/cmd/stats.rs:536:35 clippy::cast_possible_truncation "casting `f64` to `i64` may truncate the value"
+xsv/0.13.0/src/cmd/stats.rs:544:33 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+xsv/0.13.0/src/cmd/stats.rs:592:22 clippy::default_trait_access "calling `stats::MinMax::default()` is more clear than this expression"
+xsv/0.13.0/src/cmd/stats.rs:593:22 clippy::default_trait_access "calling `stats::MinMax::default()` is more clear than this expression"
+xsv/0.13.0/src/cmd/stats.rs:594:23 clippy::default_trait_access "calling `stats::MinMax::default()` is more clear than this expression"
+xsv/0.13.0/src/cmd/stats.rs:595:21 clippy::default_trait_access "calling `stats::MinMax::default()` is more clear than this expression"
+xsv/0.13.0/src/cmd/stats.rs:71:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+xsv/0.13.0/src/cmd/stats.rs:86:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv/0.13.0/src/cmd/table.rs:10:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv/0.13.0/src/cmd/table.rs:50:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv/0.13.0/src/cmd/table.rs:54:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv/0.13.0/src/config.rs:113:43 clippy::or_fun_call "use of `unwrap_or` followed by a function call"
+xsv/0.13.0/src/config.rs:58:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+xsv/0.13.0/src/config.rs:77:28 clippy::explicit_deref_methods "explicit deref method call"
+xsv/0.13.0/src/config.rs:90:13 clippy::redundant_field_names "redundant field names in struct initialization"
+xsv/0.13.0/src/index.rs:31:13 clippy::redundant_field_names "redundant field names in struct initialization"
+xsv/0.13.0/src/main.rs:164:49 clippy::redundant_clone "redundant clone"
+xsv/0.13.0/src/main.rs:1:null clippy::cargo_common_metadata "package `xsv` is missing `package.categories` metadata"
+xsv/0.13.0/src/main.rs:1:null clippy::multiple_crate_versions "multiple versions for dependency `rand_core`: 0.3.1, 0.4.2"
+xsv/0.13.0/src/main.rs:1:null clippy::multiple_crate_versions "multiple versions for dependency `rand`: 0.3.23, 0.4.6"
+xsv/0.13.0/src/main.rs:75:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv/0.13.0/src/select.rs:13:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+xsv/0.13.0/src/select.rs:154:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+xsv/0.13.0/src/select.rs:250:33 clippy::similar_names "binding's name is too similar to existing binding"
+xsv/0.13.0/src/select.rs:250:43 clippy::similar_names "binding's name is too similar to existing binding"
+xsv/0.13.0/src/select.rs:255:39 clippy::range_plus_one "an inclusive range would be more readable"
+xsv/0.13.0/src/select.rs:280:20 clippy::len_zero "length comparison to zero"
+xsv/0.13.0/src/select.rs:29:13 clippy::redundant_field_names "redundant field names in struct initialization"
+xsv/0.13.0/src/select.rs:360:62 clippy::trivially_copy_pass_by_ref "this argument (8 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+xsv/0.13.0/src/select.rs:360:9 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Option`"
+xsv/0.13.0/src/select.rs:375:9 clippy::stable_sort_primitive "used sort instead of sort_unstable to sort primitive type `usize`"
+xsv/0.13.0/src/select.rs:379:18 clippy::explicit_into_iter_loop "it is more concise to loop over containers instead of using explicit iteration methods"
+xsv/0.13.0/src/select.rs:416:5 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
+xsv/0.13.0/src/select.rs:419:9 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Option`"
+xsv/0.13.0/src/select.rs:420:27 clippy::option_option "consider using `Option<T>` instead of `Option<Option<T>>` or a custom enum if you need to distinguish all 3 cases"
+xsv/0.13.0/src/select.rs:99:17 clippy::similar_names "binding's name is too similar to existing binding"
+xsv/0.13.0/src/util.rs:150:5 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
+xsv/0.13.0/src/util.rs:37:33 clippy::map_clone "you are using an explicit closure for copying elements"
+xsv/0.13.0/src/util.rs:90:1 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"

From 4ec9cb84bb96ff11eba9d0a8961ddfea2fa1ba65 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= <matthias.krueger@famsik.de>
Date: Wed, 23 Dec 2020 15:31:18 +0100
Subject: [PATCH 092/108] cargo dev crater: refactor to get a list of all
 ClippyWarnings

---
 clippy_dev/src/crater.rs | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

diff --git a/clippy_dev/src/crater.rs b/clippy_dev/src/crater.rs
index db0dd3641f10e..96b94c2c6523b 100644
--- a/clippy_dev/src/crater.rs
+++ b/clippy_dev/src/crater.rs
@@ -106,7 +106,7 @@ impl CrateSource {
 }
 
 impl Crate {
-    fn run_clippy_lints(&self, cargo_clippy_path: &PathBuf) -> Vec<String> {
+    fn run_clippy_lints(&self, cargo_clippy_path: &PathBuf) -> Vec<ClippyWarning> {
         println!("Linting {} {}...", &self.name, &self.version);
         let cargo_clippy_path = std::fs::canonicalize(cargo_clippy_path).unwrap();
 
@@ -136,11 +136,7 @@ impl Crate {
             .filter(|line| line.contains("clippy::"))
             .map(|json_msg| parse_json_message(json_msg, &self))
             .collect();
-
-        let mut output: Vec<String> = warnings.iter().map(|warning| warning.to_string()).collect();
-        // sort messages alphabetically to avoid noise in the logs
-        output.sort();
-        output
+        warnings
     }
 }
 
@@ -219,17 +215,18 @@ pub fn run() {
     );
 
     // download and extract the crates, then run clippy on them and collect clippys warnings
+    // flatten into one big list of warnings
 
-    let clippy_lint_results: Vec<Vec<String>> = read_crates()
+    let clippy_warnings: Vec<ClippyWarning> = read_crates()
         .into_iter()
         .map(|krate| krate.download_and_extract())
         .map(|krate| krate.run_clippy_lints(&cargo_clippy_path))
+        .flatten()
         .collect();
 
-    let mut all_warnings: Vec<String> = clippy_lint_results.into_iter().flatten().collect();
-    all_warnings.sort();
+    let all_msgs: Vec<String> = clippy_warnings.iter().map(|warning| warning.to_string()).collect();
 
     // save the text into mini-crater/logs.txt
-    let text = all_warnings.join("");
+    let text = all_msgs.join("");
     write("mini-crater/logs.txt", text).unwrap();
 }

From e56c9a52532d87a36da32fbde8066ecc34e67cd4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= <matthias.krueger@famsik.de>
Date: Wed, 23 Dec 2020 15:59:16 +0100
Subject: [PATCH 093/108] cargo dev crater: gather and save lint statistics
 (how often a lint triggered)

---
 clippy_dev/src/crater.rs |  25 ++++++++-
 mini-crater/logs.txt     | 112 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 136 insertions(+), 1 deletion(-)

diff --git a/clippy_dev/src/crater.rs b/clippy_dev/src/crater.rs
index 96b94c2c6523b..7607e6b449f92 100644
--- a/clippy_dev/src/crater.rs
+++ b/clippy_dev/src/crater.rs
@@ -224,7 +224,30 @@ pub fn run() {
         .flatten()
         .collect();
 
-    let all_msgs: Vec<String> = clippy_warnings.iter().map(|warning| warning.to_string()).collect();
+    // generate some stats:
+
+    // count lint type occurrences
+    let mut counter: HashMap<&String, usize> = HashMap::new();
+    clippy_warnings
+        .iter()
+        .for_each(|wrn| *counter.entry(&wrn.linttype).or_insert(0) += 1);
+
+    // collect into a tupled list for sorting
+    let mut stats: Vec<(&&String, &usize)> = counter.iter().map(|(lint, count)| (lint, count)).collect();
+    // sort by number of lint occurences
+    stats.sort_by_key(|(_, count)| *count);
+    // biggest number first
+    stats.reverse();
+
+    let stats_formatted: String = stats
+        .iter()
+        .map(|(lint, count)| format!("{} {}\n", lint, count))
+        .collect::<String>();
+
+    let mut all_msgs: Vec<String> = clippy_warnings.iter().map(|warning| warning.to_string()).collect();
+    all_msgs.sort();
+    all_msgs.push("\n\n\n\nStats\n\n".into());
+    all_msgs.push(stats_formatted);
 
     // save the text into mini-crater/logs.txt
     let text = all_msgs.join("");
diff --git a/mini-crater/logs.txt b/mini-crater/logs.txt
index 52045f05faaff..18a0c2120ff14 100644
--- a/mini-crater/logs.txt
+++ b/mini-crater/logs.txt
@@ -3247,3 +3247,115 @@ xsv/0.13.0/src/select.rs:99:17 clippy::similar_names "binding's name is too simi
 xsv/0.13.0/src/util.rs:150:5 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
 xsv/0.13.0/src/util.rs:37:33 clippy::map_clone "you are using an explicit closure for copying elements"
 xsv/0.13.0/src/util.rs:90:1 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
+
+
+
+
+Stats
+
+clippy::must_use_candidate 552
+clippy::unreadable_literal 365
+clippy::missing_errors_doc 338
+clippy::doc_markdown 178
+clippy::wildcard_imports 160
+clippy::items_after_statements 139
+clippy::module_name_repetitions 137
+clippy::redundant_closure_for_method_calls 135
+clippy::redundant_field_names 111
+clippy::cast_possible_truncation 91
+clippy::similar_names 79
+clippy::match_same_arms 64
+clippy::inline_always 59
+clippy::single_match_else 45
+clippy::unseparated_literal_suffix 41
+clippy::enum_glob_use 40
+clippy::cast_precision_loss 35
+clippy::if_not_else 35
+clippy::filter_map 31
+clippy::too_many_lines 31
+clippy::redundant_else 29
+clippy::trivially_copy_pass_by_ref 26
+clippy::cast_lossless 23
+clippy::redundant_static_lifetimes 21
+clippy::struct_excessive_bools 20
+clippy::map_unwrap_or 20
+clippy::unusual_byte_groupings 19
+clippy::unused_self 19
+clippy::cast_possible_wrap 19
+clippy::cast_sign_loss 19
+clippy::unnecessary_wraps 19
+clippy::needless_pass_by_value 18
+clippy::default_trait_access 16
+clippy::linkedlist 14
+clippy::single_char_add_str 14
+clippy::shadow_unrelated 13
+clippy::cargo_common_metadata 13
+clippy::option_if_let_else 12
+clippy::needless_lifetimes 12
+clippy::multiple_crate_versions 11
+clippy::needless_doctest_main 10
+clippy::missing_safety_doc 10
+clippy::manual_range_contains 10
+clippy::match_wildcard_for_single_variants 10
+clippy::find_map 9
+clippy::wrong_self_convention 8
+clippy::invalid_upcast_comparisons 8
+clippy::option_map_unit_fn 7
+clippy::map_clone 7
+clippy::explicit_into_iter_loop 7
+clippy::range_plus_one 7
+clippy::manual_strip 6
+clippy::non_ascii_literal 6
+clippy::single_component_path_imports 6
+clippy::field_reassign_with_default 5
+clippy::new_without_default 5
+clippy::len_without_is_empty 5
+clippy::identity_op 5
+clippy::needless_return 5
+clippy::empty_enum 5
+clippy::match_like_matches_macro 5
+clippy::explicit_iter_loop 5
+clippy::too_many_arguments 4
+clippy::let_underscore_drop 4
+clippy::if_same_then_else 4
+clippy::filter_map_next 3
+clippy::zero_ptr 3
+clippy::fn_params_excessive_bools 3
+clippy::mut_mut 3
+clippy::manual_non_exhaustive 2
+clippy::comparison_to_empty 2
+clippy::question_mark 2
+clippy::redundant_pattern_matching 2
+clippy::write_with_newline 2
+clippy::unnecessary_cast 2
+clippy::option_option 2
+clippy::match_on_vec_items 2
+clippy::type_complexity 2
+clippy::len_zero 2
+clippy::expl_impl_clone_on_copy 2
+clippy::option_as_ref_deref 2
+clippy::unused_unit 2
+clippy::derive_hash_xor_eq 2
+clippy::while_let_on_iterator 1
+clippy::clone_on_copy 1
+clippy::same_item_push 1
+clippy::from_iter_instead_of_collect 1
+clippy::or_fun_call 1
+clippy::pub_enum_variant_names 1
+clippy::used_underscore_binding 1
+clippy::precedence 1
+clippy::redundant_clone 1
+clippy::collapsible_if 1
+clippy::stable_sort_primitive 1
+clippy::unit_arg 1
+clippy::nonminimal_bool 1
+clippy::comparison_chain 1
+clippy::mem_replace_with_default 1
+clippy::manual_saturating_arithmetic 1
+clippy::expect_fun_call 1
+clippy::should_implement_trait 1
+clippy::verbose_bit_mask 1
+clippy::int_plus_one 1
+clippy::unnecessary_lazy_evaluations 1
+clippy::from_over_into 1
+clippy::explicit_deref_methods 1

From d257101109e7ed6ca0a561a9e16d51167d2d92d7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= <matthias.krueger@famsik.de>
Date: Sun, 27 Dec 2020 15:44:45 +0100
Subject: [PATCH 094/108] make stats stable

---
 clippy_dev/src/crater.rs |   7 +-
 mini-crater/logs.txt     | 200 +++++++++++++++++++--------------------
 2 files changed, 103 insertions(+), 104 deletions(-)

diff --git a/clippy_dev/src/crater.rs b/clippy_dev/src/crater.rs
index 7607e6b449f92..b0e7cb70c895e 100644
--- a/clippy_dev/src/crater.rs
+++ b/clippy_dev/src/crater.rs
@@ -234,10 +234,9 @@ pub fn run() {
 
     // collect into a tupled list for sorting
     let mut stats: Vec<(&&String, &usize)> = counter.iter().map(|(lint, count)| (lint, count)).collect();
-    // sort by number of lint occurences
-    stats.sort_by_key(|(_, count)| *count);
-    // biggest number first
-    stats.reverse();
+    // sort by "000{count} {clippy::lintname}"
+    // to not have a lint with 200 and 2 warnings take the same spot
+    stats.sort_by_key(|(lint, count)| format!("{:0>4}, {}", count, lint));
 
     let stats_formatted: String = stats
         .iter()
diff --git a/mini-crater/logs.txt b/mini-crater/logs.txt
index 18a0c2120ff14..70b9baf039655 100644
--- a/mini-crater/logs.txt
+++ b/mini-crater/logs.txt
@@ -3059,9 +3059,9 @@ ripgrep/12.1.1/crates/core/search.rs:533:5 clippy::cast_precision_loss "casting
 ripgrep/12.1.1/crates/core/subject.rs:20:1 clippy::module_name_repetitions "item name starts with its containing module's name"
 ripgrep/12.1.1/crates/core/subject.rs:4:1 clippy::single_component_path_imports "this import is redundant"
 syn/1.0.54/build.rs:1:null clippy::cargo_common_metadata "package `syn` is missing `package.keywords` metadata"
-syn/1.0.54/build.rs:1:null clippy::multiple_crate_versions "could not read cargo metadata: failed to run `cargo metadata`:  Downloading crates ...\n  Downloaded syn-test-suite v0.0.0\nerror: failed to verify the checksum of `syn-test-suite v0.0.0`"
+syn/1.0.54/build.rs:1:null clippy::multiple_crate_versions "could not read cargo metadata: failed to run `cargo metadata`:     Blocking waiting for file lock on package cache\n    Blocking waiting for file lock on package cache\n    Blocking waiting for file lock on package cache\n Downloading crates ...\n  Downloaded ref-cast v1.0.5\n  Downloaded ref-cast-impl v1.0.5\n  Downloaded syn-test-suite v0.0.0\nerror: failed to verify the checksum of `syn-test-suite v0.0.0`"
 syn/1.0.54/src/lib.rs:1:null clippy::cargo_common_metadata "package `syn` is missing `package.keywords` metadata"
-syn/1.0.54/src/lib.rs:1:null clippy::multiple_crate_versions "could not read cargo metadata: failed to run `cargo metadata`:  Downloading crates ...\n  Downloaded syn-test-suite v0.0.0\nerror: failed to verify the checksum of `syn-test-suite v0.0.0`"
+syn/1.0.54/src/lib.rs:1:null clippy::multiple_crate_versions "could not read cargo metadata: failed to run `cargo metadata`:  Downloading crates ...\n  Downloaded openssl-sys v0.9.60\n  Downloaded syn-test-suite v0.0.0\nerror: failed to verify the checksum of `syn-test-suite v0.0.0`"
 syn/1.0.54/src/lit.rs:1397:40 clippy::redundant_else "redundant else block"
 syn/1.0.54/src/lit.rs:1405:28 clippy::redundant_else "redundant else block"
 syn/1.0.54/src/lit.rs:1485:32 clippy::redundant_else "redundant else block"
@@ -3253,109 +3253,109 @@ xsv/0.13.0/src/util.rs:90:1 clippy::needless_lifetimes "explicit lifetimes given
 
 Stats
 
-clippy::must_use_candidate 552
-clippy::unreadable_literal 365
-clippy::missing_errors_doc 338
-clippy::doc_markdown 178
-clippy::wildcard_imports 160
-clippy::items_after_statements 139
-clippy::module_name_repetitions 137
-clippy::redundant_closure_for_method_calls 135
-clippy::redundant_field_names 111
-clippy::cast_possible_truncation 91
-clippy::similar_names 79
-clippy::match_same_arms 64
-clippy::inline_always 59
-clippy::single_match_else 45
-clippy::unseparated_literal_suffix 41
-clippy::enum_glob_use 40
-clippy::cast_precision_loss 35
-clippy::if_not_else 35
-clippy::filter_map 31
-clippy::too_many_lines 31
-clippy::redundant_else 29
-clippy::trivially_copy_pass_by_ref 26
-clippy::cast_lossless 23
-clippy::redundant_static_lifetimes 21
-clippy::struct_excessive_bools 20
-clippy::map_unwrap_or 20
-clippy::unusual_byte_groupings 19
-clippy::unused_self 19
-clippy::cast_possible_wrap 19
-clippy::cast_sign_loss 19
-clippy::unnecessary_wraps 19
-clippy::needless_pass_by_value 18
-clippy::default_trait_access 16
-clippy::linkedlist 14
-clippy::single_char_add_str 14
-clippy::shadow_unrelated 13
-clippy::cargo_common_metadata 13
-clippy::option_if_let_else 12
-clippy::needless_lifetimes 12
-clippy::multiple_crate_versions 11
-clippy::needless_doctest_main 10
-clippy::missing_safety_doc 10
-clippy::manual_range_contains 10
-clippy::match_wildcard_for_single_variants 10
-clippy::find_map 9
-clippy::wrong_self_convention 8
-clippy::invalid_upcast_comparisons 8
-clippy::option_map_unit_fn 7
-clippy::map_clone 7
-clippy::explicit_into_iter_loop 7
-clippy::range_plus_one 7
-clippy::manual_strip 6
-clippy::non_ascii_literal 6
-clippy::single_component_path_imports 6
-clippy::field_reassign_with_default 5
-clippy::new_without_default 5
-clippy::len_without_is_empty 5
-clippy::identity_op 5
-clippy::needless_return 5
-clippy::empty_enum 5
-clippy::match_like_matches_macro 5
-clippy::explicit_iter_loop 5
-clippy::too_many_arguments 4
-clippy::let_underscore_drop 4
-clippy::if_same_then_else 4
-clippy::filter_map_next 3
-clippy::zero_ptr 3
-clippy::fn_params_excessive_bools 3
-clippy::mut_mut 3
-clippy::manual_non_exhaustive 2
-clippy::comparison_to_empty 2
-clippy::question_mark 2
-clippy::redundant_pattern_matching 2
-clippy::write_with_newline 2
-clippy::unnecessary_cast 2
-clippy::option_option 2
-clippy::match_on_vec_items 2
-clippy::type_complexity 2
-clippy::len_zero 2
-clippy::expl_impl_clone_on_copy 2
-clippy::option_as_ref_deref 2
-clippy::unused_unit 2
-clippy::derive_hash_xor_eq 2
-clippy::while_let_on_iterator 1
 clippy::clone_on_copy 1
-clippy::same_item_push 1
+clippy::collapsible_if 1
+clippy::comparison_chain 1
+clippy::expect_fun_call 1
+clippy::explicit_deref_methods 1
 clippy::from_iter_instead_of_collect 1
+clippy::from_over_into 1
+clippy::int_plus_one 1
+clippy::manual_saturating_arithmetic 1
+clippy::mem_replace_with_default 1
+clippy::nonminimal_bool 1
 clippy::or_fun_call 1
-clippy::pub_enum_variant_names 1
-clippy::used_underscore_binding 1
 clippy::precedence 1
+clippy::pub_enum_variant_names 1
 clippy::redundant_clone 1
-clippy::collapsible_if 1
+clippy::same_item_push 1
+clippy::should_implement_trait 1
 clippy::stable_sort_primitive 1
 clippy::unit_arg 1
-clippy::nonminimal_bool 1
-clippy::comparison_chain 1
-clippy::mem_replace_with_default 1
-clippy::manual_saturating_arithmetic 1
-clippy::expect_fun_call 1
-clippy::should_implement_trait 1
-clippy::verbose_bit_mask 1
-clippy::int_plus_one 1
 clippy::unnecessary_lazy_evaluations 1
-clippy::from_over_into 1
-clippy::explicit_deref_methods 1
+clippy::used_underscore_binding 1
+clippy::verbose_bit_mask 1
+clippy::while_let_on_iterator 1
+clippy::comparison_to_empty 2
+clippy::derive_hash_xor_eq 2
+clippy::expl_impl_clone_on_copy 2
+clippy::len_zero 2
+clippy::manual_non_exhaustive 2
+clippy::match_on_vec_items 2
+clippy::option_as_ref_deref 2
+clippy::option_option 2
+clippy::question_mark 2
+clippy::redundant_pattern_matching 2
+clippy::type_complexity 2
+clippy::unnecessary_cast 2
+clippy::unused_unit 2
+clippy::write_with_newline 2
+clippy::filter_map_next 3
+clippy::fn_params_excessive_bools 3
+clippy::mut_mut 3
+clippy::zero_ptr 3
+clippy::if_same_then_else 4
+clippy::let_underscore_drop 4
+clippy::too_many_arguments 4
+clippy::empty_enum 5
+clippy::explicit_iter_loop 5
+clippy::field_reassign_with_default 5
+clippy::identity_op 5
+clippy::len_without_is_empty 5
+clippy::match_like_matches_macro 5
+clippy::needless_return 5
+clippy::new_without_default 5
+clippy::manual_strip 6
+clippy::non_ascii_literal 6
+clippy::single_component_path_imports 6
+clippy::explicit_into_iter_loop 7
+clippy::map_clone 7
+clippy::option_map_unit_fn 7
+clippy::range_plus_one 7
+clippy::invalid_upcast_comparisons 8
+clippy::wrong_self_convention 8
+clippy::find_map 9
+clippy::manual_range_contains 10
+clippy::match_wildcard_for_single_variants 10
+clippy::missing_safety_doc 10
+clippy::needless_doctest_main 10
+clippy::multiple_crate_versions 11
+clippy::needless_lifetimes 12
+clippy::option_if_let_else 12
+clippy::cargo_common_metadata 13
+clippy::shadow_unrelated 13
+clippy::linkedlist 14
+clippy::single_char_add_str 14
+clippy::default_trait_access 16
+clippy::needless_pass_by_value 18
+clippy::cast_possible_wrap 19
+clippy::cast_sign_loss 19
+clippy::unnecessary_wraps 19
+clippy::unused_self 19
+clippy::unusual_byte_groupings 19
+clippy::map_unwrap_or 20
+clippy::struct_excessive_bools 20
+clippy::redundant_static_lifetimes 21
+clippy::cast_lossless 23
+clippy::trivially_copy_pass_by_ref 26
+clippy::redundant_else 29
+clippy::filter_map 31
+clippy::too_many_lines 31
+clippy::cast_precision_loss 35
+clippy::if_not_else 35
+clippy::enum_glob_use 40
+clippy::unseparated_literal_suffix 41
+clippy::single_match_else 45
+clippy::inline_always 59
+clippy::match_same_arms 64
+clippy::similar_names 79
+clippy::cast_possible_truncation 91
+clippy::redundant_field_names 111
+clippy::redundant_closure_for_method_calls 135
+clippy::module_name_repetitions 137
+clippy::items_after_statements 139
+clippy::wildcard_imports 160
+clippy::doc_markdown 178
+clippy::missing_errors_doc 338
+clippy::unreadable_literal 365
+clippy::must_use_candidate 552

From b6ef1e282ef4c444ce7e5694547aaff4d55c5059 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= <matthias.krueger@famsik.de>
Date: Sun, 27 Dec 2020 16:13:42 +0100
Subject: [PATCH 095/108] clippy dev crater: add option to only check a single
 one of the listed crates with  --only crate

---
 clippy_dev/src/crater.rs | 26 +++++++++++++++++++-------
 clippy_dev/src/main.rs   | 16 +++++++++++++---
 2 files changed, 32 insertions(+), 10 deletions(-)

diff --git a/clippy_dev/src/crater.rs b/clippy_dev/src/crater.rs
index b0e7cb70c895e..ee4ed451ed5d0 100644
--- a/clippy_dev/src/crater.rs
+++ b/clippy_dev/src/crater.rs
@@ -12,6 +12,7 @@ use std::collections::HashMap;
 use std::process::Command;
 use std::{fmt, fs::write, path::PathBuf};
 
+use clap::ArgMatches;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
@@ -200,7 +201,7 @@ fn parse_json_message(json_message: &str, krate: &Crate) -> ClippyWarning {
 }
 
 // the main fn
-pub fn run() {
+pub fn run(clap_config: &ArgMatches) {
     let cargo_clippy_path: PathBuf = PathBuf::from("target/debug/cargo-clippy");
 
     println!("Compiling clippy...");
@@ -217,12 +218,23 @@ pub fn run() {
     // download and extract the crates, then run clippy on them and collect clippys warnings
     // flatten into one big list of warnings
 
-    let clippy_warnings: Vec<ClippyWarning> = read_crates()
-        .into_iter()
-        .map(|krate| krate.download_and_extract())
-        .map(|krate| krate.run_clippy_lints(&cargo_clippy_path))
-        .flatten()
-        .collect();
+    let clippy_warnings: Vec<ClippyWarning> = if let Some(only_one_crate) = clap_config.value_of("only") {
+        // only check a single
+        read_crates()
+            .into_iter()
+            .map(|krate| krate.download_and_extract())
+            .filter(|krate| krate.name == only_one_crate)
+            .map(|krate| krate.run_clippy_lints(&cargo_clippy_path))
+            .flatten()
+            .collect()
+    } else {
+        read_crates()
+            .into_iter()
+            .map(|krate| krate.download_and_extract())
+            .map(|krate| krate.run_clippy_lints(&cargo_clippy_path))
+            .flatten()
+            .collect()
+    };
 
     // generate some stats:
 
diff --git a/clippy_dev/src/main.rs b/clippy_dev/src/main.rs
index 6fb8b6f2899b3..c4688ba3000a3 100644
--- a/clippy_dev/src/main.rs
+++ b/clippy_dev/src/main.rs
@@ -10,8 +10,8 @@ fn main() {
         ("bless", Some(matches)) => {
             bless::bless(matches.is_present("ignore-timestamp"));
         },
-        ("crater", Some(_)) => {
-            crater::run();
+        ("crater", Some(matches)) => {
+            crater::run(&matches);
         },
         ("fmt", Some(matches)) => {
             fmt::run(matches.is_present("check"), matches.is_present("verbose"));
@@ -59,7 +59,17 @@ fn get_clap_config<'a>() -> ArgMatches<'a> {
                         .help("Include files updated before clippy was built"),
                 ),
         )
-        .subcommand(SubCommand::with_name("crater").about("run clippy on a set of crates and check output"))
+        .subcommand(
+            SubCommand::with_name("crater")
+                .about("run clippy on a set of crates and check output")
+                .arg(
+                    Arg::with_name("only")
+                        .takes_value(true)
+                        .value_name("CRATE")
+                        .long("only")
+                        .help("only process a single crate of the list"),
+                ),
+        )
         .subcommand(
             SubCommand::with_name("fmt")
                 .about("Run rustfmt on all projects and tests")

From ec1902ce4303632bbb155ade52877c072ff52348 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= <matthias.krueger@famsik.de>
Date: Sun, 27 Dec 2020 16:20:32 +0100
Subject: [PATCH 096/108] cargo dev crater: throw an error if we can't find our
 specified crate in the .toml list

---
 clippy_dev/Cargo.toml    | 14 ++++++++------
 clippy_dev/src/crater.rs | 19 ++++++++++++++++---
 clippy_dev/src/main.rs   | 40 ++++++++++++++++++++++++----------------
 3 files changed, 48 insertions(+), 25 deletions(-)

diff --git a/clippy_dev/Cargo.toml b/clippy_dev/Cargo.toml
index d666314514206..0333a260db118 100644
--- a/clippy_dev/Cargo.toml
+++ b/clippy_dev/Cargo.toml
@@ -4,20 +4,22 @@ version = "0.0.1"
 authors = ["Philipp Hansch <dev@phansch.net>"]
 edition = "2018"
 
+
 [dependencies]
 bytecount = "0.6"
 clap = "2.33"
-flate2 = "1.0.19"
+flate2 = { version = "1.0.19" , optional = true}
 itertools = "0.9"
 opener = "0.4"
 regex = "1"
-serde = {version = "1.0", features = ["derive"]}
-serde_json = "1.0"
+serde = { version = "1.0", features = ["derive"]}
+serde_json = { version = "1.0" , optional = true}
 shell-escape = "0.1"
-tar = "0.4.30"
-toml = "0.5"
-ureq = "2.0.0-rc3"
+tar = { version = "0.4.30" , optional = true}
+toml = { version = "0.5" , optional = true}
+ureq = { version = "2.0.0-rc3" , optional = true}
 walkdir = "2"
 
 [features]
+crater = ["flate2", "serde_json", "tar", "toml", "ureq"]
 deny-warnings = []
diff --git a/clippy_dev/src/crater.rs b/clippy_dev/src/crater.rs
index ee4ed451ed5d0..61ada2c2f233f 100644
--- a/clippy_dev/src/crater.rs
+++ b/clippy_dev/src/crater.rs
@@ -4,6 +4,7 @@
 // When a new lint is introduced, we can search the results for new warnings and check for false
 // positives.
 
+#![cfg(feature = "crater")]
 #![allow(clippy::filter_map)]
 
 use crate::clippy_project_root;
@@ -218,9 +219,20 @@ pub fn run(clap_config: &ArgMatches) {
     // download and extract the crates, then run clippy on them and collect clippys warnings
     // flatten into one big list of warnings
 
+    let crates = read_crates();
+
     let clippy_warnings: Vec<ClippyWarning> = if let Some(only_one_crate) = clap_config.value_of("only") {
-        // only check a single
-        read_crates()
+        // if we don't have the specified crated in the .toml, throw an error
+        if !crates.iter().any(|krate| krate.name == only_one_crate) {
+            eprintln!(
+                "ERROR: could not find crate '{}' in clippy_dev/crater_crates.toml",
+                only_one_crate
+            );
+            std::process::exit(1);
+        }
+
+        // only check a single crate that was passed via cmdline
+        crates
             .into_iter()
             .map(|krate| krate.download_and_extract())
             .filter(|krate| krate.name == only_one_crate)
@@ -228,7 +240,8 @@ pub fn run(clap_config: &ArgMatches) {
             .flatten()
             .collect()
     } else {
-        read_crates()
+        // check all crates (default)
+        crates
             .into_iter()
             .map(|krate| krate.download_and_extract())
             .map(|krate| krate.run_clippy_lints(&cargo_clippy_path))
diff --git a/clippy_dev/src/main.rs b/clippy_dev/src/main.rs
index c4688ba3000a3..e10c3dbe0bd6f 100644
--- a/clippy_dev/src/main.rs
+++ b/clippy_dev/src/main.rs
@@ -1,7 +1,10 @@
 #![cfg_attr(feature = "deny-warnings", deny(warnings))]
 
 use clap::{App, Arg, ArgMatches, SubCommand};
-use clippy_dev::{bless, crater, fmt, new_lint, ra_setup, serve, stderr_length_check, update_lints};
+use clippy_dev::{bless, fmt, new_lint, ra_setup, serve, stderr_length_check, update_lints};
+
+#[cfg(feature = "crater")]
+use clippy_dev::crater;
 
 fn main() {
     let matches = get_clap_config();
@@ -10,6 +13,7 @@ fn main() {
         ("bless", Some(matches)) => {
             bless::bless(matches.is_present("ignore-timestamp"));
         },
+        #[cfg(feature = "crater")]
         ("crater", Some(matches)) => {
             crater::run(&matches);
         },
@@ -49,8 +53,19 @@ fn main() {
 }
 
 fn get_clap_config<'a>() -> ArgMatches<'a> {
-    App::new("Clippy developer tooling")
-        .subcommand(
+    #[cfg(feature = "crater")]
+    let crater_sbcmd = SubCommand::with_name("crater")
+        .about("run clippy on a set of crates and check output")
+        .arg(
+            Arg::with_name("only")
+                .takes_value(true)
+                .value_name("CRATE")
+                .long("only")
+                .help("only process a single crate of the list"),
+        );
+
+    let app = App::new("Clippy developer tooling")
+            .subcommand(
             SubCommand::with_name("bless")
                 .about("bless the test output changes")
                 .arg(
@@ -59,17 +74,6 @@ fn get_clap_config<'a>() -> ArgMatches<'a> {
                         .help("Include files updated before clippy was built"),
                 ),
         )
-        .subcommand(
-            SubCommand::with_name("crater")
-                .about("run clippy on a set of crates and check output")
-                .arg(
-                    Arg::with_name("only")
-                        .takes_value(true)
-                        .value_name("CRATE")
-                        .long("only")
-                        .help("only process a single crate of the list"),
-                ),
-        )
         .subcommand(
             SubCommand::with_name("fmt")
                 .about("Run rustfmt on all projects and tests")
@@ -177,6 +181,10 @@ fn get_clap_config<'a>() -> ArgMatches<'a> {
                         .validator_os(serve::validate_port),
                 )
                 .arg(Arg::with_name("lint").help("Which lint's page to load initially (optional)")),
-        )
-        .get_matches()
+        );
+
+    #[cfg(feature = "crater")]
+    let app = app.subcommand(crater_sbcmd);
+
+    app.get_matches()
 }

From 94a73d7b11d849441cd38b015393c1544422468b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= <matthias.krueger@famsik.de>
Date: Sun, 27 Dec 2020 16:56:05 +0100
Subject: [PATCH 097/108] add shortcut "dev-crater" command to build and run
 "cargo dev crater"

---
 .cargo/config | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.cargo/config b/.cargo/config
index e70da43ab47ab..220e74f5df42f 100644
--- a/.cargo/config
+++ b/.cargo/config
@@ -1,6 +1,7 @@
 [alias]
 uitest = "test --test compile-test"
 dev = "run --target-dir clippy_dev/target --package clippy_dev --bin clippy_dev --manifest-path clippy_dev/Cargo.toml --"
+dev-crater = "run --target-dir clippy_dev/target --package clippy_dev --bin clippy_dev --manifest-path clippy_dev/Cargo.toml --features crater -- crater"
 
 [build]
 rustflags = ["-Zunstable-options"]

From 48fc948ca3548d5bdcc479b5f9c317767d941e3b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= <matthias.krueger@famsik.de>
Date: Tue, 29 Dec 2020 16:18:31 +0100
Subject: [PATCH 098/108] clippy dev crater: address more review commetns

make serde a feature-dep
save clippy version in the crater log
---
 clippy_dev/Cargo.toml    | 14 +++++++-------
 clippy_dev/src/crater.rs |  9 ++++++++-
 clippy_dev/src/main.rs   |  2 +-
 mini-crater/logs.txt     | 10 ++++++++--
 4 files changed, 24 insertions(+), 11 deletions(-)

diff --git a/clippy_dev/Cargo.toml b/clippy_dev/Cargo.toml
index 0333a260db118..4268ef80282ee 100644
--- a/clippy_dev/Cargo.toml
+++ b/clippy_dev/Cargo.toml
@@ -8,18 +8,18 @@ edition = "2018"
 [dependencies]
 bytecount = "0.6"
 clap = "2.33"
-flate2 = { version = "1.0.19" , optional = true}
+flate2 = { version = "1.0.19", optional = true }
 itertools = "0.9"
 opener = "0.4"
 regex = "1"
-serde = { version = "1.0", features = ["derive"]}
-serde_json = { version = "1.0" , optional = true}
+serde = { version = "1.0", features = ["derive"], optional = true }
+serde_json = { version = "1.0", optional = true }
 shell-escape = "0.1"
-tar = { version = "0.4.30" , optional = true}
-toml = { version = "0.5" , optional = true}
-ureq = { version = "2.0.0-rc3" , optional = true}
+tar = { version = "0.4.30", optional = true }
+toml = { version = "0.5", optional = true }
+ureq = { version = "2.0.0-rc3", optional = true }
 walkdir = "2"
 
 [features]
-crater = ["flate2", "serde_json", "tar", "toml", "ureq"]
+crater = ["flate2", "serde_json", "tar", "toml", "ureq", "serde"]
 deny-warnings = []
diff --git a/clippy_dev/src/crater.rs b/clippy_dev/src/crater.rs
index 61ada2c2f233f..98a4af3591ea2 100644
--- a/clippy_dev/src/crater.rs
+++ b/clippy_dev/src/crater.rs
@@ -216,6 +216,12 @@ pub fn run(clap_config: &ArgMatches) {
         cargo_clippy_path.display()
     );
 
+    let clippy_ver = std::process::Command::new("target/debug/cargo-clippy")
+        .arg("--version")
+        .output()
+        .map(|o| String::from_utf8_lossy(&o.stdout).into_owned())
+        .expect("could not get clippy version!");
+
     // download and extract the crates, then run clippy on them and collect clippys warnings
     // flatten into one big list of warnings
 
@@ -274,6 +280,7 @@ pub fn run(clap_config: &ArgMatches) {
     all_msgs.push(stats_formatted);
 
     // save the text into mini-crater/logs.txt
-    let text = all_msgs.join("");
+    let mut text = clippy_ver; // clippy version number on top
+    text.push_str(&format!("\n{}", all_msgs.join("")));
     write("mini-crater/logs.txt", text).unwrap();
 }
diff --git a/clippy_dev/src/main.rs b/clippy_dev/src/main.rs
index e10c3dbe0bd6f..c47aabc2e0aa3 100644
--- a/clippy_dev/src/main.rs
+++ b/clippy_dev/src/main.rs
@@ -65,7 +65,7 @@ fn get_clap_config<'a>() -> ArgMatches<'a> {
         );
 
     let app = App::new("Clippy developer tooling")
-            .subcommand(
+        .subcommand(
             SubCommand::with_name("bless")
                 .about("bless the test output changes")
                 .arg(
diff --git a/mini-crater/logs.txt b/mini-crater/logs.txt
index 70b9baf039655..f9084dc8321b9 100644
--- a/mini-crater/logs.txt
+++ b/mini-crater/logs.txt
@@ -1,3 +1,5 @@
+clippy 0.0.212 (0d8a27a6f 2020-12-28)
+
 cargo/0.49.0//home/matthias/.rustup/toolchains/nightly-2020-12-20-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:393:34 clippy::match_same_arms "this `match` has identical arm bodies"
 cargo/0.49.0/build.rs:1:null clippy::cargo_common_metadata "package `cargo` is missing `package.categories` metadata"
 cargo/0.49.0/build.rs:1:null clippy::cargo_common_metadata "package `cargo` is missing `package.keywords` metadata"
@@ -107,6 +109,7 @@ cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:96:31 clippy::
 cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:98:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/core/compiler/build_plan.rs:4:9 clippy::doc_markdown "you should put `BuildPlan` between ticks in the documentation"
 cargo/0.49.0/src/cargo/core/compiler/build_plan.rs:5:66 clippy::doc_markdown "you should put `BuildPlan` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/compiler/build_plan.rs:66:40 clippy::ptr_arg "writing `&PathBuf` instead of `&Path` involves a new object where a slice will do."
 cargo/0.49.0/src/cargo/core/compiler/compilation.rs:150:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/core/compiler/compilation.rs:169:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/core/compiler/compilation.rs:185:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
@@ -237,6 +240,8 @@ cargo/0.49.0/src/cargo/core/compiler/mod.rs:364:5 clippy::items_after_statements
 cargo/0.49.0/src/cargo/core/compiler/mod.rs:364:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
 cargo/0.49.0/src/cargo/core/compiler/mod.rs:392:45 clippy::redundant_closure_for_method_calls "redundant closure found"
 cargo/0.49.0/src/cargo/core/compiler/mod.rs:415:23 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/compiler/mod.rs:464:18 clippy::ptr_arg "writing `&PathBuf` instead of `&Path` involves a new object where a slice will do."
+cargo/0.49.0/src/cargo/core/compiler/mod.rs:488:61 clippy::ptr_arg "writing `&PathBuf` instead of `&Path` involves a new object where a slice will do."
 cargo/0.49.0/src/cargo/core/compiler/mod.rs:667:15 clippy::similar_names "binding's name is too similar to existing binding"
 cargo/0.49.0/src/cargo/core/compiler/mod.rs:693:1 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
 cargo/0.49.0/src/cargo/core/compiler/mod.rs:725:42 clippy::match_same_arms "this `match` has identical arm bodies"
@@ -3059,9 +3064,9 @@ ripgrep/12.1.1/crates/core/search.rs:533:5 clippy::cast_precision_loss "casting
 ripgrep/12.1.1/crates/core/subject.rs:20:1 clippy::module_name_repetitions "item name starts with its containing module's name"
 ripgrep/12.1.1/crates/core/subject.rs:4:1 clippy::single_component_path_imports "this import is redundant"
 syn/1.0.54/build.rs:1:null clippy::cargo_common_metadata "package `syn` is missing `package.keywords` metadata"
-syn/1.0.54/build.rs:1:null clippy::multiple_crate_versions "could not read cargo metadata: failed to run `cargo metadata`:     Blocking waiting for file lock on package cache\n    Blocking waiting for file lock on package cache\n    Blocking waiting for file lock on package cache\n Downloading crates ...\n  Downloaded ref-cast v1.0.5\n  Downloaded ref-cast-impl v1.0.5\n  Downloaded syn-test-suite v0.0.0\nerror: failed to verify the checksum of `syn-test-suite v0.0.0`"
+syn/1.0.54/build.rs:1:null clippy::multiple_crate_versions "could not read cargo metadata: failed to run `cargo metadata`:  Downloading crates ...\n  Downloaded dtoa v0.4.7\n  Downloaded anyhow v1.0.37\n  Downloaded syn-test-suite v0.0.0\nerror: failed to verify the checksum of `syn-test-suite v0.0.0`"
 syn/1.0.54/src/lib.rs:1:null clippy::cargo_common_metadata "package `syn` is missing `package.keywords` metadata"
-syn/1.0.54/src/lib.rs:1:null clippy::multiple_crate_versions "could not read cargo metadata: failed to run `cargo metadata`:  Downloading crates ...\n  Downloaded openssl-sys v0.9.60\n  Downloaded syn-test-suite v0.0.0\nerror: failed to verify the checksum of `syn-test-suite v0.0.0`"
+syn/1.0.54/src/lib.rs:1:null clippy::multiple_crate_versions "could not read cargo metadata: failed to run `cargo metadata`:  Downloading crates ...\n  Downloaded syn-test-suite v0.0.0\nerror: failed to verify the checksum of `syn-test-suite v0.0.0`"
 syn/1.0.54/src/lit.rs:1397:40 clippy::redundant_else "redundant else block"
 syn/1.0.54/src/lit.rs:1405:28 clippy::redundant_else "redundant else block"
 syn/1.0.54/src/lit.rs:1485:32 clippy::redundant_else "redundant else block"
@@ -3293,6 +3298,7 @@ clippy::write_with_newline 2
 clippy::filter_map_next 3
 clippy::fn_params_excessive_bools 3
 clippy::mut_mut 3
+clippy::ptr_arg 3
 clippy::zero_ptr 3
 clippy::if_same_then_else 4
 clippy::let_underscore_drop 4

From 83fcf95f52c6e4c9dbb840ce9e562f2d5c859cca Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= <matthias.krueger@famsik.de>
Date: Sat, 23 Jan 2021 00:25:29 +0100
Subject: [PATCH 099/108] rename cargo dev crater to cargo dev lintcheck

---
 .cargo/config                                 |  2 +-
 clippy_dev/Cargo.toml                         |  2 +-
 ...ater_crates.toml => lintcheck_crates.toml} |  0
 clippy_dev/src/lib.rs                         |  2 +-
 clippy_dev/src/{crater.rs => lintcheck.rs}    | 20 +++++++++----------
 clippy_dev/src/main.rs                        | 18 ++++++++---------
 {mini-crater => lintcheck-logs}/logs.txt      |  0
 7 files changed, 22 insertions(+), 22 deletions(-)
 rename clippy_dev/{crater_crates.toml => lintcheck_crates.toml} (100%)
 rename clippy_dev/src/{crater.rs => lintcheck.rs} (94%)
 rename {mini-crater => lintcheck-logs}/logs.txt (100%)

diff --git a/.cargo/config b/.cargo/config
index 220e74f5df42f..1142cc470fe82 100644
--- a/.cargo/config
+++ b/.cargo/config
@@ -1,7 +1,7 @@
 [alias]
 uitest = "test --test compile-test"
 dev = "run --target-dir clippy_dev/target --package clippy_dev --bin clippy_dev --manifest-path clippy_dev/Cargo.toml --"
-dev-crater = "run --target-dir clippy_dev/target --package clippy_dev --bin clippy_dev --manifest-path clippy_dev/Cargo.toml --features crater -- crater"
+dev-lintcheck = "run --target-dir clippy_dev/target --package clippy_dev --bin clippy_dev --manifest-path clippy_dev/Cargo.toml --features lintcheck -- lintcheck"
 
 [build]
 rustflags = ["-Zunstable-options"]
diff --git a/clippy_dev/Cargo.toml b/clippy_dev/Cargo.toml
index 4268ef80282ee..f48c1ee5ea265 100644
--- a/clippy_dev/Cargo.toml
+++ b/clippy_dev/Cargo.toml
@@ -21,5 +21,5 @@ ureq = { version = "2.0.0-rc3", optional = true }
 walkdir = "2"
 
 [features]
-crater = ["flate2", "serde_json", "tar", "toml", "ureq", "serde"]
+lintcheck = ["flate2", "serde_json", "tar", "toml", "ureq", "serde"]
 deny-warnings = []
diff --git a/clippy_dev/crater_crates.toml b/clippy_dev/lintcheck_crates.toml
similarity index 100%
rename from clippy_dev/crater_crates.toml
rename to clippy_dev/lintcheck_crates.toml
diff --git a/clippy_dev/src/lib.rs b/clippy_dev/src/lib.rs
index 4873769b367e9..24d70d433f367 100644
--- a/clippy_dev/src/lib.rs
+++ b/clippy_dev/src/lib.rs
@@ -11,8 +11,8 @@ use std::path::{Path, PathBuf};
 use walkdir::WalkDir;
 
 pub mod bless;
-pub mod crater;
 pub mod fmt;
+pub mod lintcheck;
 pub mod new_lint;
 pub mod ra_setup;
 pub mod serve;
diff --git a/clippy_dev/src/crater.rs b/clippy_dev/src/lintcheck.rs
similarity index 94%
rename from clippy_dev/src/crater.rs
rename to clippy_dev/src/lintcheck.rs
index 98a4af3591ea2..e2099ff98c836 100644
--- a/clippy_dev/src/crater.rs
+++ b/clippy_dev/src/lintcheck.rs
@@ -4,7 +4,7 @@
 // When a new lint is introduced, we can search the results for new warnings and check for false
 // positives.
 
-#![cfg(feature = "crater")]
+#![cfg(feature = "lintcheck")]
 #![allow(clippy::filter_map)]
 
 use crate::clippy_project_root;
@@ -69,8 +69,8 @@ impl std::fmt::Display for ClippyWarning {
 
 impl CrateSource {
     fn download_and_extract(&self) -> Crate {
-        let extract_dir = PathBuf::from("target/crater/crates");
-        let krate_download_dir = PathBuf::from("target/crater/downloads");
+        let extract_dir = PathBuf::from("target/lintcheck/crates");
+        let krate_download_dir = PathBuf::from("target/lintcheck/downloads");
 
         // url to download the crate from crates.io
         let url = format!(
@@ -78,7 +78,7 @@ impl CrateSource {
             self.name, self.version
         );
         println!("Downloading and extracting {} {} from {}", self.name, self.version, url);
-        let _ = std::fs::create_dir("target/crater/");
+        let _ = std::fs::create_dir("target/lintcheck/");
         let _ = std::fs::create_dir(&krate_download_dir);
         let _ = std::fs::create_dir(&extract_dir);
 
@@ -112,7 +112,7 @@ impl Crate {
         println!("Linting {} {}...", &self.name, &self.version);
         let cargo_clippy_path = std::fs::canonicalize(cargo_clippy_path).unwrap();
 
-        let shared_target_dir = clippy_project_root().join("target/crater/shared_target_dir/");
+        let shared_target_dir = clippy_project_root().join("target/lintcheck/shared_target_dir/");
 
         let all_output = std::process::Command::new(cargo_clippy_path)
             .env("CARGO_TARGET_DIR", shared_target_dir)
@@ -149,9 +149,9 @@ fn build_clippy() {
         .expect("Failed to build clippy!");
 }
 
-// get a list of CrateSources we want to check from a "crater_crates.toml" file.
+// get a list of CrateSources we want to check from a "lintcheck_crates.toml" file.
 fn read_crates() -> Vec<CrateSource> {
-    let toml_path = PathBuf::from("clippy_dev/crater_crates.toml");
+    let toml_path = PathBuf::from("clippy_dev/lintcheck_crates.toml");
     let toml_content: String =
         std::fs::read_to_string(&toml_path).unwrap_or_else(|_| panic!("Failed to read {}", toml_path.display()));
     let crate_list: CrateList =
@@ -231,7 +231,7 @@ pub fn run(clap_config: &ArgMatches) {
         // if we don't have the specified crated in the .toml, throw an error
         if !crates.iter().any(|krate| krate.name == only_one_crate) {
             eprintln!(
-                "ERROR: could not find crate '{}' in clippy_dev/crater_crates.toml",
+                "ERROR: could not find crate '{}' in clippy_dev/lintcheck_crates.toml",
                 only_one_crate
             );
             std::process::exit(1);
@@ -279,8 +279,8 @@ pub fn run(clap_config: &ArgMatches) {
     all_msgs.push("\n\n\n\nStats\n\n".into());
     all_msgs.push(stats_formatted);
 
-    // save the text into mini-crater/logs.txt
+    // save the text into lintcheck-logs/logs.txt
     let mut text = clippy_ver; // clippy version number on top
     text.push_str(&format!("\n{}", all_msgs.join("")));
-    write("mini-crater/logs.txt", text).unwrap();
+    write("lintcheck-logs/logs.txt", text).unwrap();
 }
diff --git a/clippy_dev/src/main.rs b/clippy_dev/src/main.rs
index c47aabc2e0aa3..e7a298a37e17a 100644
--- a/clippy_dev/src/main.rs
+++ b/clippy_dev/src/main.rs
@@ -3,8 +3,8 @@
 use clap::{App, Arg, ArgMatches, SubCommand};
 use clippy_dev::{bless, fmt, new_lint, ra_setup, serve, stderr_length_check, update_lints};
 
-#[cfg(feature = "crater")]
-use clippy_dev::crater;
+#[cfg(feature = "lintcheck")]
+use clippy_dev::lintcheck;
 
 fn main() {
     let matches = get_clap_config();
@@ -13,9 +13,9 @@ fn main() {
         ("bless", Some(matches)) => {
             bless::bless(matches.is_present("ignore-timestamp"));
         },
-        #[cfg(feature = "crater")]
-        ("crater", Some(matches)) => {
-            crater::run(&matches);
+        #[cfg(feature = "lintcheck")]
+        ("lintcheck", Some(matches)) => {
+            lintcheck::run(&matches);
         },
         ("fmt", Some(matches)) => {
             fmt::run(matches.is_present("check"), matches.is_present("verbose"));
@@ -53,8 +53,8 @@ fn main() {
 }
 
 fn get_clap_config<'a>() -> ArgMatches<'a> {
-    #[cfg(feature = "crater")]
-    let crater_sbcmd = SubCommand::with_name("crater")
+    #[cfg(feature = "lintcheck")]
+    let lintcheck_sbcmd = SubCommand::with_name("lintcheck")
         .about("run clippy on a set of crates and check output")
         .arg(
             Arg::with_name("only")
@@ -183,8 +183,8 @@ fn get_clap_config<'a>() -> ArgMatches<'a> {
                 .arg(Arg::with_name("lint").help("Which lint's page to load initially (optional)")),
         );
 
-    #[cfg(feature = "crater")]
-    let app = app.subcommand(crater_sbcmd);
+    #[cfg(feature = "lintcheck")]
+    let app = app.subcommand(lintcheck_sbcmd);
 
     app.get_matches()
 }
diff --git a/mini-crater/logs.txt b/lintcheck-logs/logs.txt
similarity index 100%
rename from mini-crater/logs.txt
rename to lintcheck-logs/logs.txt

From d0d28b11d7d9948747404ca0cb0a06280e1c15fb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= <matthias.krueger@famsik.de>
Date: Sat, 23 Jan 2021 01:08:48 +0100
Subject: [PATCH 100/108] update lintcheck-logs

---
 lintcheck-logs/logs.txt | 213 ++++++++++++++++++++--------------------
 1 file changed, 109 insertions(+), 104 deletions(-)

diff --git a/lintcheck-logs/logs.txt b/lintcheck-logs/logs.txt
index f9084dc8321b9..f61e9b38775d2 100644
--- a/lintcheck-logs/logs.txt
+++ b/lintcheck-logs/logs.txt
@@ -1,9 +1,9 @@
-clippy 0.0.212 (0d8a27a6f 2020-12-28)
+clippy 0.1.51 (c6701036b 2021-01-23)
 
-cargo/0.49.0//home/matthias/.rustup/toolchains/nightly-2020-12-20-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:393:34 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0//home/matthias/.rustup/toolchains/nightly-2021-01-15-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:393:34 clippy::match_same_arms "this `match` has identical arm bodies"
 cargo/0.49.0/build.rs:1:null clippy::cargo_common_metadata "package `cargo` is missing `package.categories` metadata"
 cargo/0.49.0/build.rs:1:null clippy::cargo_common_metadata "package `cargo` is missing `package.keywords` metadata"
-cargo/0.49.0/src/bin/cargo/cli.rs:104:34 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/bin/cargo/cli.rs:104:34 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 cargo/0.49.0/src/bin/cargo/cli.rs:121:5 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
 cargo/0.49.0/src/bin/cargo/cli.rs:157:30 clippy::redundant_closure_for_method_calls "redundant closure found"
 cargo/0.49.0/src/bin/cargo/cli.rs:184:41 clippy::cast_possible_truncation "casting `u64` to `u32` may truncate the value"
@@ -68,7 +68,7 @@ cargo/0.49.0/src/bin/cargo/commands/yank.rs:35:36 clippy::redundant_closure_for_
 cargo/0.49.0/src/bin/cargo/main.rs:100:17 clippy::match_wildcard_for_single_variants "wildcard match will miss any future added variants"
 cargo/0.49.0/src/bin/cargo/main.rs:118:41 clippy::redundant_closure_for_method_calls "redundant closure found"
 cargo/0.49.0/src/bin/cargo/main.rs:137:43 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/bin/cargo/main.rs:148:19 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/bin/cargo/main.rs:148:19 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 cargo/0.49.0/src/bin/cargo/main.rs:174:57 clippy::redundant_closure_for_method_calls "redundant closure found"
 cargo/0.49.0/src/bin/cargo/main.rs:18:5 clippy::wildcard_imports "usage of wildcard import"
 cargo/0.49.0/src/bin/cargo/main.rs:1:null clippy::cargo_common_metadata "package `cargo` is missing `package.categories` metadata"
@@ -95,16 +95,16 @@ cargo/0.49.0/src/cargo/core/compiler/build_context/mod.rs:83:20 clippy::doc_mark
 cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:108:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:121:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:149:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:411:9 clippy::needless_question_mark "Question mark operator is useless here"
 cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:420:69 clippy::doc_markdown "you should put `mode/target_kind` between ticks in the documentation"
 cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:423:19 clippy::doc_markdown "you should put `CrateTypes` between ticks in the documentation"
 cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:424:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:469:58 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:591:20 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
 cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:603:19 clippy::redundant_closure_for_method_calls "redundant closure found"
 cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:665:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:82:31 clippy::doc_markdown "you should put `FileType` between ticks in the documentation"
 cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:83:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:84:9 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:84:9 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:96:31 clippy::doc_markdown "you should put `FileType` between ticks in the documentation"
 cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:98:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/core/compiler/build_plan.rs:4:9 clippy::doc_markdown "you should put `BuildPlan` between ticks in the documentation"
@@ -119,12 +119,14 @@ cargo/0.49.0/src/cargo/core/compiler/compilation.rs:198:5 clippy::missing_errors
 cargo/0.49.0/src/cargo/core/compiler/compilation.rs:314:16 clippy::doc_markdown "you should put `rustc_tool` between ticks in the documentation"
 cargo/0.49.0/src/cargo/core/compiler/compilation.rs:91:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/core/compiler/compile_kind.rs:118:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/compiler/compile_kind.rs:123:18 clippy::case_sensitive_file_extension_comparisons "case-sensitive file extension comparison"
 cargo/0.49.0/src/cargo/core/compiler/compile_kind.rs:147:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/core/compiler/compile_kind.rs:157:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/core/compiler/compile_kind.rs:29:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/core/compiler/compile_kind.rs:33:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/core/compiler/compile_kind.rs:49:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/context/compilation_files.rs:204:9 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/compiler/compile_kind.rs:69:48 clippy::case_sensitive_file_extension_comparisons "case-sensitive file extension comparison"
+cargo/0.49.0/src/cargo/core/compiler/context/compilation_files.rs:204:9 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 cargo/0.49.0/src/cargo/core/compiler/context/compilation_files.rs:277:22 clippy::doc_markdown "you should put `OUT_DIR` between ticks in the documentation"
 cargo/0.49.0/src/cargo/core/compiler/context/compilation_files.rs:324:66 clippy::doc_markdown "you should put `FileType` between ticks in the documentation"
 cargo/0.49.0/src/cargo/core/compiler/context/compilation_files.rs:393:37 clippy::match_same_arms "this `match` has identical arm bodies"
@@ -139,7 +141,6 @@ cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:349:5 clippy::missing_errors
 cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:354:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:358:21 clippy::doc_markdown "you should put `RunCustomBuild` between ticks in the documentation"
 cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:361:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:365:9 clippy::find_map "called `find(..).map(..)` on an `Iterator`"
 cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:374:43 clippy::doc_markdown "you should put `RunCustomBuild` between ticks in the documentation"
 cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:378:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:383:41 clippy::doc_markdown "you should put `RunCustomBuild` between ticks in the documentation"
@@ -150,14 +151,13 @@ cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:523:5 clippy::must_use_candi
 cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:538:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:542:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:83:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:92:25 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:92:25 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 cargo/0.49.0/src/cargo/core/compiler/crate_type.rs:16:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/core/compiler/crate_type.rs:29:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/core/compiler/crate_type.rs:40:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/core/compiler/crate_type.rs:49:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/core/compiler/crate_type.rs:60:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:150:1 clippy::too_many_lines "this function has too many lines (230/100)"
-cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:154:29 clippy::find_map "called `find(..).map(..)` on an `Iterator`"
 cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:353:56 clippy::manual_strip "stripping a prefix manually"
 cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:448:27 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
 cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:464:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
@@ -167,16 +167,13 @@ cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:561:5 clippy::missing_error
 cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:567:20 clippy::redundant_closure_for_method_calls "redundant closure found"
 cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:576:28 clippy::shadow_unrelated "`mut value` is being shadowed"
 cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:606:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:624:13 clippy::find_map "called `find(..).map(..)` on an `Iterator`"
 cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:688:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
 cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:756:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
 cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:762:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
 cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:762:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
 cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:823:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1021:51 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1252:20 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1278:19 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1656:16 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1656:16 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1664:5 clippy::field_reassign_with_default "field assignment outside of initializer for an instance created with Default::default()"
 cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1787:5 clippy::similar_names "binding's name is too similar to existing binding"
 cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1795:5 clippy::field_reassign_with_default "field assignment outside of initializer for an instance created with Default::default()"
@@ -208,9 +205,8 @@ cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:875:33 clippy::similar_names
 cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:876:32 clippy::similar_names "binding's name is too similar to existing binding"
 cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:896:30 clippy::similar_names "binding's name is too similar to existing binding"
 cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:897:30 clippy::similar_names "binding's name is too similar to existing binding"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:991:37 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:991:37 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:12:5 clippy::doc_markdown "you should put `src/librustc_jobserver/lib.rs` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:282:30 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
 cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:329:13 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
 cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:332:23 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
 cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:34:53 clippy::doc_markdown "you should put `NeedsToken` between ticks in the documentation"
@@ -219,6 +215,7 @@ cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:37:6 clippy::doc_markdown "you
 cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:40:5 clippy::doc_markdown "you should put `NeedsToken` between ticks in the documentation"
 cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:40:56 clippy::doc_markdown "you should put `NeedsToken` between ticks in the documentation"
 cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:43:6 clippy::doc_markdown "you should put `ReleaseToken` between ticks in the documentation"
+cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:748:16 clippy::collapsible_else_if "this `else { if .. }` block can be collapsed"
 cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:749:13 clippy::if_not_else "unnecessary boolean `not` operation"
 cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:786:26 clippy::unused_self "unused `self` argument"
 cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:81:61 clippy::doc_markdown "you should put `DrainState` between ticks in the documentation"
@@ -230,16 +227,17 @@ cargo/0.49.0/src/cargo/core/compiler/links.rs:8:1 clippy::module_name_repetition
 cargo/0.49.0/src/cargo/core/compiler/mod.rs:1016:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/core/compiler/mod.rs:1094:19 clippy::redundant_closure_for_method_calls "redundant closure found"
 cargo/0.49.0/src/cargo/core/compiler/mod.rs:1131:1 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+cargo/0.49.0/src/cargo/core/compiler/mod.rs:1268:34 clippy::case_sensitive_file_extension_comparisons "case-sensitive file extension comparison"
 cargo/0.49.0/src/cargo/core/compiler/mod.rs:1277:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
 cargo/0.49.0/src/cargo/core/compiler/mod.rs:179:1 clippy::too_many_lines "this function has too many lines (162/100)"
 cargo/0.49.0/src/cargo/core/compiler/mod.rs:198:78 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/compiler/mod.rs:201:25 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/compiler/mod.rs:201:25 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 cargo/0.49.0/src/cargo/core/compiler/mod.rs:267:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
 cargo/0.49.0/src/cargo/core/compiler/mod.rs:324:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
 cargo/0.49.0/src/cargo/core/compiler/mod.rs:364:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
 cargo/0.49.0/src/cargo/core/compiler/mod.rs:364:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
 cargo/0.49.0/src/cargo/core/compiler/mod.rs:392:45 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/compiler/mod.rs:415:23 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/compiler/mod.rs:415:23 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 cargo/0.49.0/src/cargo/core/compiler/mod.rs:464:18 clippy::ptr_arg "writing `&PathBuf` instead of `&Path` involves a new object where a slice will do."
 cargo/0.49.0/src/cargo/core/compiler/mod.rs:488:61 clippy::ptr_arg "writing `&PathBuf` instead of `&Path` involves a new object where a slice will do."
 cargo/0.49.0/src/cargo/core/compiler/mod.rs:667:15 clippy::similar_names "binding's name is too similar to existing binding"
@@ -275,9 +273,6 @@ cargo/0.49.0/src/cargo/core/compiler/unit.rs:161:5 clippy::must_use_candidate "t
 cargo/0.49.0/src/cargo/core/compiler/unit.rs:35:1 clippy::module_name_repetitions "item name starts with its containing module's name"
 cargo/0.49.0/src/cargo/core/compiler/unit_dependencies.rs:154:29 clippy::doc_markdown "you should put `state.unit_dependencies` between ticks in the documentation"
 cargo/0.49.0/src/cargo/core/compiler/unit_dependencies.rs:213:1 clippy::too_many_lines "this function has too many lines (110/100)"
-cargo/0.49.0/src/cargo/core/compiler/unit_dependencies.rs:329:13 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
-cargo/0.49.0/src/cargo/core/compiler/unit_dependencies.rs:480:5 clippy::find_map "called `find(..).map(..)` on an `Iterator`"
-cargo/0.49.0/src/cargo/core/compiler/unit_dependencies.rs:511:5 clippy::find_map "called `find(..).map(..)` on an `Iterator`"
 cargo/0.49.0/src/cargo/core/compiler/unit_dependencies.rs:52:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/core/compiler/unit_dependencies.rs:52:1 clippy::module_name_repetitions "item name ends with its containing module's name"
 cargo/0.49.0/src/cargo/core/compiler/unit_graph.rs:65:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
@@ -446,13 +441,14 @@ cargo/0.49.0/src/cargo/core/package.rs:453:60 clippy::redundant_closure_for_meth
 cargo/0.49.0/src/cargo/core/package.rs:459:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/core/package.rs:473:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/core/package.rs:587:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/core/package.rs:588:9 clippy::needless_question_mark "Question mark operator is useless here"
 cargo/0.49.0/src/cargo/core/package.rs:682:46 clippy::cast_possible_truncation "casting `f64` to `u64` may truncate the value"
 cargo/0.49.0/src/cargo/core/package.rs:682:46 clippy::cast_sign_loss "casting `f64` to `u64` may lose the sign of the value"
 cargo/0.49.0/src/cargo/core/package.rs:682:63 clippy::cast_possible_truncation "casting `f64` to `u64` may truncate the value"
 cargo/0.49.0/src/cargo/core/package.rs:682:63 clippy::cast_sign_loss "casting `f64` to `u64` may lose the sign of the value"
 cargo/0.49.0/src/cargo/core/package.rs:731:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/package.rs:790:13 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
-cargo/0.49.0/src/cargo/core/package.rs:988:9 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/package.rs:790:13 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/package.rs:988:9 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 cargo/0.49.0/src/cargo/core/package_id.rs:115:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/core/package_id.rs:124:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/core/package_id.rs:139:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
@@ -470,7 +466,7 @@ cargo/0.49.0/src/cargo/core/package_id_spec.rs:151:5 clippy::must_use_candidate
 cargo/0.49.0/src/cargo/core/package_id_spec.rs:160:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/core/package_id_spec.rs:179:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/core/package_id_spec.rs:212:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/core/package_id_spec.rs:231:9 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/package_id_spec.rs:231:9 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 cargo/0.49.0/src/cargo/core/package_id_spec.rs:51:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/core/package_id_spec.rs:77:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/core/package_id_spec.rs:88:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
@@ -506,7 +502,7 @@ cargo/0.49.0/src/cargo/core/registry.rs:344:49 clippy::redundant_closure_for_met
 cargo/0.49.0/src/cargo/core/registry.rs:369:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/core/registry.rs:424:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/core/registry.rs:49:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-cargo/0.49.0/src/cargo/core/registry.rs:520:17 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/registry.rs:520:17 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 cargo/0.49.0/src/cargo/core/registry.rs:763:53 clippy::redundant_closure_for_method_calls "redundant closure found"
 cargo/0.49.0/src/cargo/core/registry.rs:765:53 clippy::redundant_closure_for_method_calls "redundant closure found"
 cargo/0.49.0/src/cargo/core/registry.rs:807:14 clippy::redundant_closure_for_method_calls "redundant closure found"
@@ -514,7 +510,6 @@ cargo/0.49.0/src/cargo/core/registry.rs:814:53 clippy::redundant_closure_for_met
 cargo/0.49.0/src/cargo/core/resolver/conflict_cache.rs:197:29 clippy::redundant_closure_for_method_calls "redundant closure found"
 cargo/0.49.0/src/cargo/core/resolver/conflict_cache.rs:41:38 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
 cargo/0.49.0/src/cargo/core/resolver/context.rs:274:53 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/resolver/context.rs:297:9 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
 cargo/0.49.0/src/cargo/core/resolver/context.rs:42:1 clippy::module_name_repetitions "item name starts with its containing module's name"
 cargo/0.49.0/src/cargo/core/resolver/context.rs:74:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/core/resolver/encode.rs:156:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
@@ -525,7 +520,7 @@ cargo/0.49.0/src/cargo/core/resolver/encode.rs:449:5 clippy::items_after_stateme
 cargo/0.49.0/src/cargo/core/resolver/encode.rs:529:34 clippy::redundant_closure_for_method_calls "redundant closure found"
 cargo/0.49.0/src/cargo/core/resolver/encode.rs:602:59 clippy::redundant_closure_for_method_calls "redundant closure found"
 cargo/0.49.0/src/cargo/core/resolver/encode.rs:623:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/core/resolver/encode.rs:652:27 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/resolver/encode.rs:652:27 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 cargo/0.49.0/src/cargo/core/resolver/encode.rs:674:51 clippy::redundant_closure_for_method_calls "redundant closure found"
 cargo/0.49.0/src/cargo/core/resolver/errors.rs:103:22 clippy::redundant_closure_for_method_calls "redundant closure found"
 cargo/0.49.0/src/cargo/core/resolver/errors.rs:104:22 clippy::redundant_closure_for_method_calls "redundant closure found"
@@ -542,17 +537,15 @@ cargo/0.49.0/src/cargo/core/resolver/features.rs:186:23 clippy::doc_markdown "yo
 cargo/0.49.0/src/cargo/core/resolver/features.rs:187:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/core/resolver/features.rs:199:23 clippy::doc_markdown "you should put `RequestedFeatures` between ticks in the documentation"
 cargo/0.49.0/src/cargo/core/resolver/features.rs:200:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/resolver/features.rs:209:9 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
 cargo/0.49.0/src/cargo/core/resolver/features.rs:221:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/core/resolver/features.rs:231:21 clippy::doc_markdown "you should put `pkg_id/is_build` between ticks in the documentation"
 cargo/0.49.0/src/cargo/core/resolver/features.rs:233:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/core/resolver/features.rs:247:58 clippy::redundant_closure_for_method_calls "redundant closure found"
 cargo/0.49.0/src/cargo/core/resolver/features.rs:278:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/core/resolver/features.rs:394:27 clippy::doc_markdown "you should put `FeatureValue` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/resolver/features.rs:460:19 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/resolver/features.rs:460:19 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 cargo/0.49.0/src/cargo/core/resolver/features.rs:480:24 clippy::doc_markdown "you should put `FeatureValues` between ticks in the documentation"
 cargo/0.49.0/src/cargo/core/resolver/features.rs:496:24 clippy::doc_markdown "you should put `FeatureValues` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/resolver/features.rs:561:28 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
 cargo/0.49.0/src/cargo/core/resolver/features.rs:58:1 clippy::module_name_repetitions "item name ends with its containing module's name"
 cargo/0.49.0/src/cargo/core/resolver/features.rs:67:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
 cargo/0.49.0/src/cargo/core/resolver/mod.rs:1017:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
@@ -560,14 +553,12 @@ cargo/0.49.0/src/cargo/core/resolver/mod.rs:1045:57 clippy::redundant_closure_fo
 cargo/0.49.0/src/cargo/core/resolver/mod.rs:122:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/core/resolver/mod.rs:142:44 clippy::redundant_closure_for_method_calls "redundant closure found"
 cargo/0.49.0/src/cargo/core/resolver/mod.rs:180:1 clippy::too_many_lines "this function has too many lines (225/100)"
-cargo/0.49.0/src/cargo/core/resolver/mod.rs:311:17 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/resolver/mod.rs:311:17 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 cargo/0.49.0/src/cargo/core/resolver/mod.rs:421:52 clippy::filter_map_next "called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find_map(..)` instead."
-cargo/0.49.0/src/cargo/core/resolver/mod.rs:437:33 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
 cargo/0.49.0/src/cargo/core/resolver/mod.rs:457:69 clippy::filter_map_next "called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find_map(..)` instead."
 cargo/0.49.0/src/cargo/core/resolver/mod.rs:470:37 clippy::similar_names "binding's name is too similar to existing binding"
-cargo/0.49.0/src/cargo/core/resolver/mod.rs:480:37 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
 cargo/0.49.0/src/cargo/core/resolver/mod.rs:607:11 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
-cargo/0.49.0/src/cargo/core/resolver/mod.rs:631:21 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/resolver/mod.rs:631:21 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 cargo/0.49.0/src/cargo/core/resolver/mod.rs:942:15 clippy::if_not_else "unnecessary boolean `not` operation"
 cargo/0.49.0/src/cargo/core/resolver/mod.rs:988:20 clippy::redundant_else "redundant else block"
 cargo/0.49.0/src/cargo/core/resolver/resolve.rs:120:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
@@ -592,7 +583,6 @@ cargo/0.49.0/src/cargo/core/resolver/resolve.rs:354:5 clippy::must_use_candidate
 cargo/0.49.0/src/cargo/core/resolver/resolve.rs:362:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/core/resolver/resolve.rs:60:1 clippy::module_name_repetitions "item name starts with its containing module's name"
 cargo/0.49.0/src/cargo/core/resolver/resolve.rs:76:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/resolver/resolve.rs:90:35 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
 cargo/0.49.0/src/cargo/core/resolver/types.rs:111:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/core/resolver/types.rs:121:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/core/resolver/types.rs:141:19 clippy::doc_markdown "you should put `ResolveOpts` between ticks in the documentation"
@@ -602,7 +592,7 @@ cargo/0.49.0/src/cargo/core/resolver/types.rs:181:9 clippy::map_unwrap_or "calle
 cargo/0.49.0/src/cargo/core/resolver/types.rs:187:5 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
 cargo/0.49.0/src/cargo/core/resolver/types.rs:261:5 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
 cargo/0.49.0/src/cargo/core/shell.rs:113:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/shell.rs:130:9 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/shell.rs:130:9 clippy::single_match_else "you seem to be trying to use `match` for an equality check. Consider using `if`"
 cargo/0.49.0/src/cargo/core/shell.rs:148:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/core/shell.rs:153:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/core/shell.rs:163:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
@@ -732,7 +722,6 @@ cargo/0.49.0/src/cargo/core/summary.rs:90:5 clippy::must_use_candidate "this met
 cargo/0.49.0/src/cargo/core/summary.rs:93:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/core/summary.rs:96:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/core/summary.rs:99:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/workspace.rs:1019:59 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
 cargo/0.49.0/src/cargo/core/workspace.rs:1056:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
 cargo/0.49.0/src/cargo/core/workspace.rs:113:1 clippy::module_name_repetitions "item name starts with its containing module's name"
 cargo/0.49.0/src/cargo/core/workspace.rs:1157:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
@@ -746,12 +735,11 @@ cargo/0.49.0/src/cargo/core/workspace.rs:267:5 clippy::missing_errors_doc "docs
 cargo/0.49.0/src/cargo/core/workspace.rs:329:37 clippy::doc_markdown "you should put `VirtualManifest` between ticks in the documentation"
 cargo/0.49.0/src/cargo/core/workspace.rs:410:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/core/workspace.rs:440:9 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
-cargo/0.49.0/src/cargo/core/workspace.rs:511:32 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/workspace.rs:511:32 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 cargo/0.49.0/src/cargo/core/workspace.rs:561:25 clippy::non_ascii_literal "literal non-ASCII character detected"
 cargo/0.49.0/src/cargo/core/workspace.rs:613:13 clippy::filter_map "called `filter_map(..).map(..)` on an `Iterator`"
 cargo/0.49.0/src/cargo/core/workspace.rs:615:22 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/workspace.rs:688:35 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
-cargo/0.49.0/src/cargo/core/workspace.rs:762:27 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/core/workspace.rs:762:27 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 cargo/0.49.0/src/cargo/core/workspace.rs:784:17 clippy::if_not_else "unnecessary boolean `not` operation"
 cargo/0.49.0/src/cargo/core/workspace.rs:849:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/core/workspace.rs:893:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
@@ -776,12 +764,12 @@ cargo/0.49.0/src/cargo/ops/cargo_compile.rs:109:5 clippy::missing_errors_doc "do
 cargo/0.49.0/src/cargo/ops/cargo_compile.rs:119:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/ops/cargo_compile.rs:1227:17 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
 cargo/0.49.0/src/cargo/ops/cargo_compile.rs:127:35 clippy::from_iter_instead_of_collect "usage of `FromIterator::from_iter`"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:128:32 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
 cargo/0.49.0/src/cargo/ops/cargo_compile.rs:173:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/ops/cargo_compile.rs:205:36 clippy::match_same_arms "this `match` has identical arm bodies"
 cargo/0.49.0/src/cargo/ops/cargo_compile.rs:242:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/ops/cargo_compile.rs:249:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/ops/cargo_compile.rs:258:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/ops/cargo_compile.rs:267:16 clippy::needless_question_mark "Question mark operator is useless here"
 cargo/0.49.0/src/cargo/ops/cargo_compile.rs:275:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/ops/cargo_compile.rs:275:1 clippy::too_many_lines "this function has too many lines (219/100)"
 cargo/0.49.0/src/cargo/ops/cargo_compile.rs:468:9 clippy::default_trait_access "calling `std::collections::HashMap::default()` is more clear than this expression"
@@ -809,7 +797,6 @@ cargo/0.49.0/src/cargo/ops/cargo_compile.rs:874:69 clippy::redundant_closure_for
 cargo/0.49.0/src/cargo/ops/cargo_doc.rs:20:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/ops/cargo_fetch.rs:15:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/ops/cargo_fetch.rs:27:46 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/ops/cargo_fetch.rs:36:20 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
 cargo/0.49.0/src/cargo/ops/cargo_generate_lockfile.rs:160:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
 cargo/0.49.0/src/cargo/ops/cargo_generate_lockfile.rs:175:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
 cargo/0.49.0/src/cargo/ops/cargo_generate_lockfile.rs:22:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
@@ -818,10 +805,12 @@ cargo/0.49.0/src/cargo/ops/cargo_generate_lockfile.rs:37:1 clippy::too_many_line
 cargo/0.49.0/src/cargo/ops/cargo_install.rs:13:5 clippy::wildcard_imports "usage of wildcard import"
 cargo/0.49.0/src/cargo/ops/cargo_install.rs:148:1 clippy::fn_params_excessive_bools "more than 3 bools in function parameters"
 cargo/0.49.0/src/cargo/ops/cargo_install.rs:148:1 clippy::too_many_lines "this function has too many lines (316/100)"
+cargo/0.49.0/src/cargo/ops/cargo_install.rs:178:24 clippy::collapsible_else_if "this `else { if .. }` block can be collapsed"
 cargo/0.49.0/src/cargo/ops/cargo_install.rs:202:17 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo/0.49.0/src/cargo/ops/cargo_install.rs:236:16 clippy::collapsible_else_if "this `else { if .. }` block can be collapsed"
 cargo/0.49.0/src/cargo/ops/cargo_install.rs:312:64 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/ops/cargo_install.rs:318:63 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
 cargo/0.49.0/src/cargo/ops/cargo_install.rs:32:13 clippy::let_underscore_drop "non-binding `let` on a type that implements `Drop`"
+cargo/0.49.0/src/cargo/ops/cargo_install.rs:339:12 clippy::collapsible_else_if "this `else { if .. }` block can be collapsed"
 cargo/0.49.0/src/cargo/ops/cargo_install.rs:37:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/ops/cargo_install.rs:454:22 clippy::redundant_closure_for_method_calls "redundant closure found"
 cargo/0.49.0/src/cargo/ops/cargo_install.rs:483:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
@@ -837,20 +826,18 @@ cargo/0.49.0/src/cargo/ops/cargo_new.rs:525:9 clippy::doc_markdown "you should p
 cargo/0.49.0/src/cargo/ops/cargo_new.rs:572:34 clippy::match_same_arms "this `match` has identical arm bodies"
 cargo/0.49.0/src/cargo/ops/cargo_new.rs:623:1 clippy::too_many_lines "this function has too many lines (130/100)"
 cargo/0.49.0/src/cargo/ops/cargo_new.rs:781:5 clippy::filter_map_next "called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find_map(..)` instead."
-cargo/0.49.0/src/cargo/ops/cargo_new.rs:800:16 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/ops/cargo_new.rs:800:16 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 cargo/0.49.0/src/cargo/ops/cargo_output_metadata.rs:163:36 clippy::redundant_closure_for_method_calls "redundant closure found"
 cargo/0.49.0/src/cargo/ops/cargo_output_metadata.rs:27:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/ops/cargo_output_metadata.rs:45:45 clippy::redundant_closure_for_method_calls "redundant closure found"
 cargo/0.49.0/src/cargo/ops/cargo_package.rs:144:1 clippy::too_many_lines "this function has too many lines (112/100)"
-cargo/0.49.0/src/cargo/ops/cargo_package.rs:207:13 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/ops/cargo_package.rs:207:13 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 cargo/0.49.0/src/cargo/ops/cargo_package.rs:25:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
 cargo/0.49.0/src/cargo/ops/cargo_package.rs:307:54 clippy::redundant_closure_for_method_calls "redundant closure found"
 cargo/0.49.0/src/cargo/ops/cargo_package.rs:394:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/ops/cargo_package.rs:418:21 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
 cargo/0.49.0/src/cargo/ops/cargo_package.rs:425:61 clippy::redundant_closure_for_method_calls "redundant closure found"
 cargo/0.49.0/src/cargo/ops/cargo_package.rs:459:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
 cargo/0.49.0/src/cargo/ops/cargo_package.rs:66:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/cargo_package.rs:769:29 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
 cargo/0.49.0/src/cargo/ops/cargo_package.rs:93:20 clippy::if_not_else "unnecessary boolean `not` operation"
 cargo/0.49.0/src/cargo/ops/cargo_pkgid.rs:5:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/ops/cargo_read_manifest.rs:14:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
@@ -875,18 +862,13 @@ cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:244:22 clippy::do
 cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:244:63 clippy::doc_markdown "you should put `PackageId` between ticks in the documentation"
 cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:253:17 clippy::if_not_else "unnecessary boolean `not` operation"
 cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:370:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
-cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:392:9 clippy::find_map "called `find(..).map(..)` on an `Iterator`"
 cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:505:8 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
 cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:525:10 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
 cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:542:27 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:542:5 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:542:5 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:561:20 clippy::redundant_else "redundant else block"
 cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:613:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
 cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:645:41 clippy::doc_markdown "you should put `BTreeSet` between ticks in the documentation"
-cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:654:42 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
-cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:662:14 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
-cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:674:17 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
-cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:681:17 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
 cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:92:19 clippy::doc_markdown "you should put `InstallTracker` between ticks in the documentation"
 cargo/0.49.0/src/cargo/ops/fix.rs:200:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/ops/fix.rs:200:1 clippy::module_name_repetitions "item name starts with its containing module's name"
@@ -910,14 +892,13 @@ cargo/0.49.0/src/cargo/ops/lockfile.rs:8:1 clippy::missing_errors_doc "docs for
 cargo/0.49.0/src/cargo/ops/lockfile.rs:8:1 clippy::module_name_repetitions "item name ends with its containing module's name"
 cargo/0.49.0/src/cargo/ops/registry.rs:150:21 clippy::redundant_closure_for_method_calls "redundant closure found"
 cargo/0.49.0/src/cargo/ops/registry.rs:188:1 clippy::too_many_lines "this function has too many lines (130/100)"
-cargo/0.49.0/src/cargo/ops/registry.rs:196:16 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
 cargo/0.49.0/src/cargo/ops/registry.rs:212:32 clippy::if_not_else "unnecessary `!=` operation"
 cargo/0.49.0/src/cargo/ops/registry.rs:222:53 clippy::redundant_closure_for_method_calls "redundant closure found"
 cargo/0.49.0/src/cargo/ops/registry.rs:224:44 clippy::redundant_closure_for_method_calls "redundant closure found"
 cargo/0.49.0/src/cargo/ops/registry.rs:31:1 clippy::module_name_repetitions "item name starts with its containing module's name"
 cargo/0.49.0/src/cargo/ops/registry.rs:346:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/ops/registry.rs:346:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/ops/registry.rs:351:26 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/ops/registry.rs:351:26 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 cargo/0.49.0/src/cargo/ops/registry.rs:385:12 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
 cargo/0.49.0/src/cargo/ops/registry.rs:386:15 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
 cargo/0.49.0/src/cargo/ops/registry.rs:38:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
@@ -934,17 +915,17 @@ cargo/0.49.0/src/cargo/ops/registry.rs:621:5 clippy::missing_errors_doc "docs fo
 cargo/0.49.0/src/cargo/ops/registry.rs:671:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/ops/registry.rs:671:1 clippy::module_name_repetitions "item name starts with its containing module's name"
 cargo/0.49.0/src/cargo/ops/registry.rs:674:10 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
-cargo/0.49.0/src/cargo/ops/registry.rs:678:17 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/ops/registry.rs:678:17 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 cargo/0.49.0/src/cargo/ops/registry.rs:730:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/registry.rs:731:16 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/ops/registry.rs:731:16 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 cargo/0.49.0/src/cargo/ops/registry.rs:785:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/registry.rs:794:16 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/ops/registry.rs:794:16 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 cargo/0.49.0/src/cargo/ops/registry.rs:828:14 clippy::doc_markdown "you should put `SourceId` between ticks in the documentation"
 cargo/0.49.0/src/cargo/ops/registry.rs:848:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/ops/resolve.rs:199:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/ops/resolve.rs:199:1 clippy::module_name_repetitions "item name starts with its containing module's name"
 cargo/0.49.0/src/cargo/ops/resolve.rs:199:1 clippy::too_many_lines "this function has too many lines (137/100)"
-cargo/0.49.0/src/cargo/ops/resolve.rs:241:28 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/ops/resolve.rs:241:28 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 cargo/0.49.0/src/cargo/ops/resolve.rs:28:1 clippy::module_name_repetitions "item name ends with its containing module's name"
 cargo/0.49.0/src/cargo/ops/resolve.rs:384:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/ops/resolve.rs:417:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
@@ -955,13 +936,12 @@ cargo/0.49.0/src/cargo/ops/resolve.rs:602:5 clippy::items_after_statements "addi
 cargo/0.49.0/src/cargo/ops/resolve.rs:75:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/ops/resolve.rs:75:1 clippy::module_name_repetitions "item name starts with its containing module's name"
 cargo/0.49.0/src/cargo/ops/tree/graph.rs:129:26 clippy::doc_markdown "you should put `PackageIds` between ticks in the documentation"
-cargo/0.49.0/src/cargo/ops/tree/graph.rs:131:47 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
 cargo/0.49.0/src/cargo/ops/tree/graph.rs:152:15 clippy::match_on_vec_items "indexing into a vector may panic"
 cargo/0.49.0/src/cargo/ops/tree/graph.rs:173:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
 cargo/0.49.0/src/cargo/ops/tree/graph.rs:234:46 clippy::filter_map "called `filter(..).flat_map(..)` on an `Iterator`"
 cargo/0.49.0/src/cargo/ops/tree/graph.rs:328:44 clippy::match_same_arms "this `match` has identical arm bodies"
 cargo/0.49.0/src/cargo/ops/tree/graph.rs:330:50 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/ops/tree/graph.rs:563:35 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/ops/tree/graph.rs:563:35 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 cargo/0.49.0/src/cargo/ops/tree/mod.rs:112:11 clippy::non_ascii_literal "literal non-ASCII character detected"
 cargo/0.49.0/src/cargo/ops/tree/mod.rs:113:10 clippy::non_ascii_literal "literal non-ASCII character detected"
 cargo/0.49.0/src/cargo/ops/tree/mod.rs:114:10 clippy::non_ascii_literal "literal non-ASCII character detected"
@@ -974,9 +954,13 @@ cargo/0.49.0/src/cargo/ops/tree/mod.rs:58:5 clippy::must_use_candidate "this met
 cargo/0.49.0/src/cargo/ops/vendor.rs:14:1 clippy::module_name_repetitions "item name starts with its containing module's name"
 cargo/0.49.0/src/cargo/ops/vendor.rs:21:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/ops/vendor.rs:314:34 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo/0.49.0/src/cargo/ops/vendor.rs:320:29 clippy::case_sensitive_file_extension_comparisons "case-sensitive file extension comparison"
+cargo/0.49.0/src/cargo/ops/vendor.rs:320:60 clippy::case_sensitive_file_extension_comparisons "case-sensitive file extension comparison"
 cargo/0.49.0/src/cargo/ops/vendor.rs:324:13 clippy::match_wildcard_for_single_variants "wildcard match will miss any future added variants"
 cargo/0.49.0/src/cargo/ops/vendor.rs:70:1 clippy::too_many_lines "this function has too many lines (175/100)"
 cargo/0.49.0/src/cargo/sources/config.rs:102:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/sources/config.rs:111:28 clippy::needless_question_mark "Question mark operator is useless here"
+cargo/0.49.0/src/cargo/sources/config.rs:133:48 clippy::needless_question_mark "Question mark operator is useless here"
 cargo/0.49.0/src/cargo/sources/config.rs:135:67 clippy::redundant_closure_for_method_calls "redundant closure found"
 cargo/0.49.0/src/cargo/sources/config.rs:206:36 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
 cargo/0.49.0/src/cargo/sources/config.rs:282:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
@@ -990,8 +974,10 @@ cargo/0.49.0/src/cargo/sources/git/source.rs:25:5 clippy::missing_errors_doc "do
 cargo/0.49.0/src/cargo/sources/git/source.rs:49:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/sources/git/source.rs:53:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/sources/git/source.rs:69:20 clippy::comparison_to_empty "comparison to empty slice"
-cargo/0.49.0/src/cargo/sources/git/utils.rs:1025:19 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/sources/git/utils.rs:1025:19 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/sources/git/utils.rs:1157:36 clippy::case_sensitive_file_extension_comparisons "case-sensitive file extension comparison"
 cargo/0.49.0/src/cargo/sources/git/utils.rs:1158:9 clippy::manual_strip "stripping a suffix manually"
+cargo/0.49.0/src/cargo/sources/git/utils.rs:134:12 clippy::upper_case_acronyms "name `GitShortID` contains a capitalized acronym"
 cargo/0.49.0/src/cargo/sources/git/utils.rs:176:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/sources/git/utils.rs:180:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/sources/git/utils.rs:184:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
@@ -1006,9 +992,10 @@ cargo/0.49.0/src/cargo/sources/git/utils.rs:308:5 clippy::missing_errors_doc "do
 cargo/0.49.0/src/cargo/sources/git/utils.rs:472:9 clippy::let_underscore_drop "non-binding `let` on a type that implements `Drop`"
 cargo/0.49.0/src/cargo/sources/git/utils.rs:489:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
 cargo/0.49.0/src/cargo/sources/git/utils.rs:503:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/sources/git/utils.rs:528:28 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/sources/git/utils.rs:528:28 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 cargo/0.49.0/src/cargo/sources/git/utils.rs:537:21 clippy::let_underscore_drop "non-binding `let` on a type that implements `Drop`"
 cargo/0.49.0/src/cargo/sources/git/utils.rs:588:1 clippy::too_many_lines "this function has too many lines (135/100)"
+cargo/0.49.0/src/cargo/sources/git/utils.rs:692:9 clippy::vec_init_then_push "calls to `push` immediately after creation"
 cargo/0.49.0/src/cargo/sources/git/utils.rs:758:9 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
 cargo/0.49.0/src/cargo/sources/git/utils.rs:858:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/sources/path.rs:129:44 clippy::match_same_arms "this `match` has identical arm bodies"
@@ -1034,7 +1021,6 @@ cargo/0.49.0/src/cargo/sources/registry/index.rs:121:70 clippy::unseparated_lite
 cargo/0.49.0/src/cargo/sources/registry/index.rs:167:1 clippy::module_name_repetitions "item name ends with its containing module's name"
 cargo/0.49.0/src/cargo/sources/registry/index.rs:215:1 clippy::module_name_repetitions "item name starts with its containing module's name"
 cargo/0.49.0/src/cargo/sources/registry/index.rs:324:23 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/sources/registry/index.rs:393:25 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
 cargo/0.49.0/src/cargo/sources/registry/index.rs:468:40 clippy::doc_markdown "you should put `SourceId` between ticks in the documentation"
 cargo/0.49.0/src/cargo/sources/registry/index.rs:590:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
 cargo/0.49.0/src/cargo/sources/registry/index.rs:648:17 clippy::similar_names "binding's name is too similar to existing binding"
@@ -1056,10 +1042,11 @@ cargo/0.49.0/src/cargo/sources/registry/mod.rs:582:20 clippy::redundant_else "re
 cargo/0.49.0/src/cargo/sources/registry/mod.rs:621:9 clippy::if_not_else "unnecessary `!=` operation"
 cargo/0.49.0/src/cargo/sources/registry/remote.rs:139:17 clippy::unused_self "unused `self` argument"
 cargo/0.49.0/src/cargo/sources/registry/remote.rs:32:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/sources/registry/remote.rs:72:13 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/sources/registry/remote.rs:72:13 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 cargo/0.49.0/src/cargo/sources/replaced.rs:12:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/sources/replaced.rs:5:1 clippy::module_name_repetitions "item name starts with its containing module's name"
 cargo/0.49.0/src/cargo/util/canonical_url.rs:19:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/canonical_url.rs:50:41 clippy::case_sensitive_file_extension_comparisons "case-sensitive file extension comparison"
 cargo/0.49.0/src/cargo/util/canonical_url.rs:65:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/util/command_prelude.rs:218:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/util/command_prelude.rs:222:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
@@ -1106,8 +1093,11 @@ cargo/0.49.0/src/cargo/util/config/mod.rs:1064:5 clippy::missing_errors_doc "doc
 cargo/0.49.0/src/cargo/util/config/mod.rs:1090:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/util/config/mod.rs:1166:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/util/config/mod.rs:1179:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1181:33 clippy::needless_question_mark "Question mark operator is useless here"
 cargo/0.49.0/src/cargo/util/config/mod.rs:1184:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1186:33 clippy::needless_question_mark "Question mark operator is useless here"
 cargo/0.49.0/src/cargo/util/config/mod.rs:1189:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1191:33 clippy::needless_question_mark "Question mark operator is useless here"
 cargo/0.49.0/src/cargo/util/config/mod.rs:1203:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/util/config/mod.rs:1211:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/util/config/mod.rs:1216:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
@@ -1116,7 +1106,7 @@ cargo/0.49.0/src/cargo/util/config/mod.rs:1229:5 clippy::missing_errors_doc "doc
 cargo/0.49.0/src/cargo/util/config/mod.rs:124:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
 cargo/0.49.0/src/cargo/util/config/mod.rs:1254:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/util/config/mod.rs:1279:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1281:9 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+cargo/0.49.0/src/cargo/util/config/mod.rs:1281:9 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 cargo/0.49.0/src/cargo/util/config/mod.rs:1323:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
 cargo/0.49.0/src/cargo/util/config/mod.rs:1339:39 clippy::unused_self "unused `self` argument"
 cargo/0.49.0/src/cargo/util/config/mod.rs:1344:1 clippy::module_name_repetitions "item name starts with its containing module's name"
@@ -1176,7 +1166,6 @@ cargo/0.49.0/src/cargo/util/cpu.rs:22:5 clippy::must_use_candidate "this method
 cargo/0.49.0/src/cargo/util/cpu.rs:82:25 clippy::cast_precision_loss "casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
 cargo/0.49.0/src/cargo/util/cpu.rs:82:9 clippy::cast_precision_loss "casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
 cargo/0.49.0/src/cargo/util/dependency_queue.rs:109:27 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/util/dependency_queue.rs:136:20 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
 cargo/0.49.0/src/cargo/util/dependency_queue.rs:151:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/util/dependency_queue.rs:156:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/util/dependency_queue.rs:46:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
@@ -1220,10 +1209,8 @@ cargo/0.49.0/src/cargo/util/flock.rs:37:5 clippy::must_use_candidate "this metho
 cargo/0.49.0/src/cargo/util/flock.rs:43:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/util/flock.rs:52:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/util/graph.rs:10:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/graph.rs:115:13 clippy::find_map "called `find(..).map(..)` on an `Iterator`"
 cargo/0.49.0/src/cargo/util/graph.rs:41:51 clippy::redundant_closure_for_method_calls "redundant closure found"
 cargo/0.49.0/src/cargo/util/graph.rs:45:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/graph.rs:95:13 clippy::find_map "called `find(..).map(..)` on an `Iterator`"
 cargo/0.49.0/src/cargo/util/hasher.rs:12:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/util/hasher.rs:9:1 clippy::module_name_repetitions "item name ends with its containing module's name"
 cargo/0.49.0/src/cargo/util/hex.rs:10:9 clippy::cast_possible_truncation "casting `u64` to `u8` may truncate the value"
@@ -1327,7 +1314,6 @@ cargo/0.49.0/src/cargo/util/rustc.rs:114:5 clippy::doc_markdown "you should put
 cargo/0.49.0/src/cargo/util/rustc.rs:115:5 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
 cargo/0.49.0/src/cargo/util/rustc.rs:162:17 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
 cargo/0.49.0/src/cargo/util/rustc.rs:39:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/rustc.rs:55:13 clippy::find_map "called `find(..).map(..)` on an `Iterator`"
 cargo/0.49.0/src/cargo/util/sha256.rs:10:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/util/sha256.rs:20:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/util/sha256.rs:31:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
@@ -1365,7 +1351,6 @@ cargo/0.49.0/src/cargo/util/toml/mod.rs:83:42 clippy::redundant_closure_for_meth
 cargo/0.49.0/src/cargo/util/toml/mod.rs:852:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/util/toml/mod.rs:852:5 clippy::too_many_lines "this function has too many lines (138/100)"
 cargo/0.49.0/src/cargo/util/toml/mod.rs:962:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:971:24 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
 cargo/0.49.0/src/cargo/util/toml/mod.rs:979:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
 cargo/0.49.0/src/cargo/util/toml/mod.rs:98:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
 cargo/0.49.0/src/cargo/util/toml/mod.rs:999:23 clippy::default_trait_access "calling `util::toml::DetailedTomlDependency::default()` is more clear than this expression"
@@ -1376,7 +1361,6 @@ cargo/0.49.0/src/cargo/util/toml/targets.rs:593:42 clippy::redundant_closure_for
 cargo/0.49.0/src/cargo/util/toml/targets.rs:605:19 clippy::redundant_closure_for_method_calls "redundant closure found"
 cargo/0.49.0/src/cargo/util/toml/targets.rs:612:42 clippy::redundant_closure_for_method_calls "redundant closure found"
 cargo/0.49.0/src/cargo/util/toml/targets.rs:756:36 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/util/toml/targets.rs:810:24 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
 cargo/0.49.0/src/cargo/util/vcs.rs:10:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
 cargo/0.49.0/src/cargo/util/vcs.rs:33:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
 cargo/0.49.0/src/cargo/util/vcs.rs:37:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
@@ -1445,7 +1429,7 @@ iron/0.6.1/src/request/url.rs:63:5 clippy::must_use_candidate "this method could
 iron/0.6.1/src/request/url.rs:73:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 iron/0.6.1/src/request/url.rs:83:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 iron/0.6.1/src/request/url.rs:96:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-iron/0.6.1/src/response.rs:121:19 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+iron/0.6.1/src/response.rs:121:19 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 iron/0.6.1/src/response.rs:125:43 clippy::redundant_closure_for_method_calls "redundant closure found"
 iron/0.6.1/src/response.rs:139:41 clippy::redundant_closure_for_method_calls "redundant closure found"
 iron/0.6.1/src/response.rs:24:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
@@ -1593,8 +1577,11 @@ libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:1120:38 clippy::unreadable_lite
 libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:178:34 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
 libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:291:5 clippy::missing_safety_doc "unsafe function's docs miss `# Safety` section"
 libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:291:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:299:11 clippy::ptr_as_ptr "`as` casting between raw pointers without changing its mutability"
 libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:302:5 clippy::missing_safety_doc "unsafe function's docs miss `# Safety` section"
 libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:302:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:312:11 clippy::ptr_as_ptr "`as` casting between raw pointers without changing its mutability"
+libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:352:20 clippy::ptr_as_ptr "`as` casting between raw pointers without changing its mutability"
 libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:355:13 clippy::missing_safety_doc "unsafe function's docs miss `# Safety` section"
 libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:355:13 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:359:13 clippy::missing_safety_doc "unsafe function's docs miss `# Safety` section"
@@ -1779,6 +1766,7 @@ libc/0.2.81/src/unix/linux_like/linux/mod.rs:2500:45 clippy::unreadable_literal
 libc/0.2.81/src/unix/linux_like/linux/mod.rs:2572:9 clippy::needless_return "unneeded `return` statement"
 libc/0.2.81/src/unix/linux_like/linux/mod.rs:2578:20 clippy::zero_ptr "`0 as *mut _` detected"
 libc/0.2.81/src/unix/linux_like/linux/mod.rs:2588:13 clippy::zero_ptr "`0 as *mut _` detected"
+libc/0.2.81/src/unix/linux_like/linux/mod.rs:2590:13 clippy::ptr_as_ptr "`as` casting between raw pointers without changing its mutability"
 libc/0.2.81/src/unix/linux_like/linux/mod.rs:2596:52 clippy::used_underscore_binding "used binding `_dummy` which is prefixed with an underscore. A leading underscore signals that a binding will not be used."
 libc/0.2.81/src/unix/linux_like/linux/mod.rs:2597:11 clippy::cast_sign_loss "casting `i32` to `usize` may lose the sign of the value"
 libc/0.2.81/src/unix/linux_like/linux/mod.rs:2601:21 clippy::explicit_iter_loop "it is more concise to loop over references to containers instead of using explicit iteration methods"
@@ -1799,7 +1787,6 @@ libc/0.2.81/src/unix/linux_like/linux/mod.rs:2664:25 clippy::unreadable_literal
 libc/0.2.81/src/unix/linux_like/linux/mod.rs:2665:16 clippy::identity_op "the operation is ineffective. Consider reducing it to `(minor & 0x000000ff)`"
 libc/0.2.81/src/unix/linux_like/linux/mod.rs:2665:25 clippy::unreadable_literal "long literal lacking separators"
 libc/0.2.81/src/unix/linux_like/linux/mod.rs:2666:25 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:40:1 clippy::empty_enum "enum with no variants"
 libc/0.2.81/src/unix/linux_like/linux/mod.rs:954:34 clippy::unreadable_literal "long literal lacking separators"
 libc/0.2.81/src/unix/linux_like/mod.rs:1000:31 clippy::unreadable_literal "long literal lacking separators"
 libc/0.2.81/src/unix/linux_like/mod.rs:1001:32 clippy::unreadable_literal "long literal lacking separators"
@@ -1879,6 +1866,7 @@ libc/0.2.81/src/unix/linux_like/mod.rs:1179:32 clippy::unreadable_literal "long
 libc/0.2.81/src/unix/linux_like/mod.rs:1180:31 clippy::unreadable_literal "long literal lacking separators"
 libc/0.2.81/src/unix/linux_like/mod.rs:1218:27 clippy::identity_op "the operation is ineffective. Consider reducing it to `IPOPT_CONTROL`"
 libc/0.2.81/src/unix/linux_like/mod.rs:1314:9 clippy::precedence "operator precedence can trip the unwary"
+libc/0.2.81/src/unix/linux_like/mod.rs:1321:13 clippy::ptr_as_ptr "`as` casting between raw pointers without changing its mutability"
 libc/0.2.81/src/unix/linux_like/mod.rs:1323:13 clippy::zero_ptr "`0 as *mut _` detected"
 libc/0.2.81/src/unix/linux_like/mod.rs:1332:9 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
 libc/0.2.81/src/unix/linux_like/mod.rs:1337:9 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
@@ -1909,7 +1897,6 @@ libc/0.2.81/src/unix/linux_like/mod.rs:608:35 clippy::unreadable_literal "long l
 libc/0.2.81/src/unix/linux_like/mod.rs:764:35 clippy::unreadable_literal "long literal lacking separators"
 libc/0.2.81/src/unix/linux_like/mod.rs:765:39 clippy::unreadable_literal "long literal lacking separators"
 libc/0.2.81/src/unix/linux_like/mod.rs:991:30 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:9:1 clippy::empty_enum "enum with no variants"
 libc/0.2.81/src/unix/mod.rs:198:29 clippy::unreadable_literal "long literal lacking separators"
 libc/0.2.81/src/unix/mod.rs:199:28 clippy::unreadable_literal "long literal lacking separators"
 libc/0.2.81/src/unix/mod.rs:201:35 clippy::unnecessary_cast "casting integer literal to `usize` is unnecessary"
@@ -1917,9 +1904,8 @@ libc/0.2.81/src/unix/mod.rs:202:35 clippy::unnecessary_cast "casting integer lit
 libc/0.2.81/src/unix/mod.rs:282:40 clippy::unreadable_literal "long literal lacking separators"
 libc/0.2.81/src/unix/mod.rs:284:41 clippy::unreadable_literal "long literal lacking separators"
 libc/0.2.81/src/unix/mod.rs:285:36 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/mod.rs:34:1 clippy::empty_enum "enum with no variants"
-libc/0.2.81/src/unix/mod.rs:386:1 clippy::empty_enum "enum with no variants"
-libc/0.2.81/src/unix/mod.rs:394:1 clippy::empty_enum "enum with no variants"
+libc/0.2.81/src/unix/mod.rs:34:10 clippy::upper_case_acronyms "name `DIR` contains a capitalized acronym"
+libc/0.2.81/src/unix/mod.rs:386:10 clippy::upper_case_acronyms "name `FILE` contains a capitalized acronym"
 log/0.4.11/src/lib.rs:1047:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 log/0.4.11/src/lib.rs:1053:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 log/0.4.11/src/lib.rs:1059:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
@@ -1935,7 +1921,6 @@ log/0.4.11/src/lib.rs:1407:1 clippy::must_use_candidate "this function could hav
 log/0.4.11/src/lib.rs:329:27 clippy::derive_hash_xor_eq "you are deriving `Hash` but have implemented `PartialEq` explicitly"
 log/0.4.11/src/lib.rs:356:1 clippy::expl_impl_clone_on_copy "you are implementing `Clone` explicitly on a `Copy` type"
 log/0.4.11/src/lib.rs:448:12 clippy::manual_range_contains "manual `RangeInclusive::contains` implementation"
-log/0.4.11/src/lib.rs:468:13 clippy::filter_map "called `filter(..).map(..)` on an `Iterator`"
 log/0.4.11/src/lib.rs:500:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 log/0.4.11/src/lib.rs:506:28 clippy::trivially_copy_pass_by_ref "this argument (8 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
 log/0.4.11/src/lib.rs:506:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
@@ -2018,6 +2003,7 @@ proc-macro2/1.0.24/src/parse.rs:602:20 clippy::map_unwrap_or "called `map(<f>).u
 proc-macro2/1.0.24/src/parse.rs:696:29 clippy::cast_lossless "casting `u8` to `u64` may become silently lossy if you later change the type"
 proc-macro2/1.0.24/src/parse.rs:702:34 clippy::cast_lossless "casting `u8` to `u64` may become silently lossy if you later change the type"
 proc-macro2/1.0.24/src/parse.rs:708:34 clippy::cast_lossless "casting `u8` to `u64` may become silently lossy if you later change the type"
+proc-macro2/1.0.24/src/parse.rs:793:5 clippy::vec_init_then_push "calls to `push` immediately after creation"
 proc-macro2/1.0.24/src/parse.rs:803:15 clippy::explicit_iter_loop "it is more concise to loop over references to containers instead of using explicit iteration methods"
 proc-macro2/1.0.24/src/parse.rs:808:15 clippy::explicit_iter_loop "it is more concise to loop over references to containers instead of using explicit iteration methods"
 proc-macro2/1.0.24/src/wrapper.rs:415:24 clippy::trivially_copy_pass_by_ref "this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
@@ -2138,13 +2124,16 @@ rand/0.7.3/src/distributions/uniform.rs:943:54 clippy::cast_possible_truncation
 rand/0.7.3/src/distributions/unit_circle.rs:30:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 rand/0.7.3/src/distributions/unit_sphere.rs:24:1 clippy::module_name_repetitions "item name starts with its containing module's name"
 rand/0.7.3/src/distributions/unit_sphere.rs:29:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand/0.7.3/src/distributions/utils.rs:218:18 clippy::upper_case_acronyms "name `FloatSIMDUtils` contains a capitalized acronym"
 rand/0.7.3/src/distributions/utils.rs:247:15 clippy::wrong_self_convention "methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name"
 rand/0.7.3/src/distributions/utils.rs:248:20 clippy::wrong_self_convention "methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name"
 rand/0.7.3/src/distributions/utils.rs:249:18 clippy::wrong_self_convention "methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name"
+rand/0.7.3/src/distributions/utils.rs:253:18 clippy::upper_case_acronyms "name `FloatAsSIMD` contains a capitalized acronym"
 rand/0.7.3/src/distributions/utils.rs:254:5 clippy::inline_always "you have declared `#[inline(always)]` on `lanes`. This is usually a bad idea"
 rand/0.7.3/src/distributions/utils.rs:258:5 clippy::inline_always "you have declared `#[inline(always)]` on `splat`. This is usually a bad idea"
 rand/0.7.3/src/distributions/utils.rs:262:5 clippy::inline_always "you have declared `#[inline(always)]` on `extract`. This is usually a bad idea"
 rand/0.7.3/src/distributions/utils.rs:267:5 clippy::inline_always "you have declared `#[inline(always)]` on `replace`. This is usually a bad idea"
+rand/0.7.3/src/distributions/utils.rs:274:18 clippy::upper_case_acronyms "name `BoolAsSIMD` contains a capitalized acronym"
 rand/0.7.3/src/distributions/utils.rs:281:5 clippy::inline_always "you have declared `#[inline(always)]` on `any`. This is usually a bad idea"
 rand/0.7.3/src/distributions/utils.rs:286:5 clippy::inline_always "you have declared `#[inline(always)]` on `all`. This is usually a bad idea"
 rand/0.7.3/src/distributions/utils.rs:291:5 clippy::inline_always "you have declared `#[inline(always)]` on `none`. This is usually a bad idea"
@@ -2306,7 +2295,7 @@ rayon/1.5.0/src/iter/collect/consumer.rs:1:5 clippy::wildcard_imports "usage of
 rayon/1.5.0/src/iter/collect/consumer.rs:28:5 clippy::doc_markdown "you should put `CollectResult` between ticks in the documentation"
 rayon/1.5.0/src/iter/collect/consumer.rs:36:37 clippy::mut_mut "generally you want to avoid `&mut &mut _` if possible"
 rayon/1.5.0/src/iter/collect/consumer.rs:36:37 clippy::mut_mut "generally you want to avoid `&mut &mut _` if possible"
-rayon/1.5.0/src/iter/collect/mod.rs:154:9 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+rayon/1.5.0/src/iter/collect/mod.rs:154:9 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 rayon/1.5.0/src/iter/copied.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
 rayon/1.5.0/src/iter/copied.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
 rayon/1.5.0/src/iter/copied.rs:71:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
@@ -2460,7 +2449,7 @@ rayon/1.5.0/src/iter/update.rs:1:5 clippy::wildcard_imports "usage of wildcard i
 rayon/1.5.0/src/iter/update.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
 rayon/1.5.0/src/iter/update.rs:82:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
 rayon/1.5.0/src/iter/update.rs:87:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/while_some.rs:130:22 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+rayon/1.5.0/src/iter/while_some.rs:130:22 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 rayon/1.5.0/src/iter/while_some.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
 rayon/1.5.0/src/iter/while_some.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
 rayon/1.5.0/src/iter/zip.rs:102:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
@@ -2718,6 +2707,7 @@ regex/1.3.2/src/exec.rs:1270:17 clippy::doc_markdown "you should put `RegexSet`
 regex/1.3.2/src/exec.rs:1280:17 clippy::doc_markdown "you should put `RegexSet` between ticks in the documentation"
 regex/1.3.2/src/exec.rs:137:9 clippy::field_reassign_with_default "field assignment outside of initializer for an instance created with Default::default()"
 regex/1.3.2/src/exec.rs:142:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex/1.3.2/src/exec.rs:1493:5 clippy::upper_case_acronyms "name `PikeVM` contains a capitalized acronym"
 regex/1.3.2/src/exec.rs:158:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 regex/1.3.2/src/exec.rs:168:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 regex/1.3.2/src/exec.rs:181:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
@@ -2764,12 +2754,12 @@ regex/1.3.2/src/exec.rs:981:14 clippy::doc_markdown "you should put `find_nfa` b
 regex/1.3.2/src/expand.rs:170:27 clippy::trivially_copy_pass_by_ref "this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
 regex/1.3.2/src/expand.rs:171:5 clippy::match_like_matches_macro "match expression looks like `matches!` macro"
 regex/1.3.2/src/expand.rs:22:13 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
-regex/1.3.2/src/expand.rs:27:23 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+regex/1.3.2/src/expand.rs:27:23 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 regex/1.3.2/src/expand.rs:30:17 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
 regex/1.3.2/src/expand.rs:38:30 clippy::map_unwrap_or "called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead"
 regex/1.3.2/src/expand.rs:42:21 clippy::map_unwrap_or "called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead"
 regex/1.3.2/src/expand.rs:50:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-regex/1.3.2/src/expand.rs:69:23 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+regex/1.3.2/src/expand.rs:69:23 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 regex/1.3.2/src/expand.rs:80:28 clippy::map_unwrap_or "called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead"
 regex/1.3.2/src/expand.rs:84:21 clippy::map_unwrap_or "called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead"
 regex/1.3.2/src/expand.rs:8:1 clippy::module_name_repetitions "item name starts with its containing module's name"
@@ -2807,8 +2797,10 @@ regex/1.3.2/src/literal/imp.rs:160:30 clippy::match_same_arms "this `match` has
 regex/1.3.2/src/literal/imp.rs:167:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 regex/1.3.2/src/literal/imp.rs:168:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
 regex/1.3.2/src/literal/imp.rs:211:20 clippy::redundant_else "redundant else block"
+regex/1.3.2/src/literal/imp.rs:239:5 clippy::upper_case_acronyms "name `AC` contains a capitalized acronym"
 regex/1.3.2/src/literal/imp.rs:276:50 clippy::match_same_arms "this `match` has identical arm bodies"
 regex/1.3.2/src/literal/imp.rs:342:41 clippy::inline_always "you have declared `#[inline(always)]` on `find`. This is usually a bad idea"
+regex/1.3.2/src/literal/imp.rs:34:5 clippy::upper_case_acronyms "name `AC` contains a capitalized acronym"
 regex/1.3.2/src/literal/imp.rs:435:13 clippy::redundant_field_names "redundant field names in struct initialization"
 regex/1.3.2/src/literal/imp.rs:436:13 clippy::redundant_field_names "redundant field names in struct initialization"
 regex/1.3.2/src/literal/imp.rs:437:13 clippy::redundant_field_names "redundant field names in struct initialization"
@@ -2849,6 +2841,7 @@ regex/1.3.2/src/pikevm.rs:224:5 clippy::too_many_arguments "this function has to
 regex/1.3.2/src/pikevm.rs:234:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
 regex/1.3.2/src/pikevm.rs:303:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
 regex/1.3.2/src/pikevm.rs:331:29 clippy::mut_mut "this expression mutably borrows a mutable reference. Consider reborrowing"
+regex/1.3.2/src/pikevm.rs:70:5 clippy::upper_case_acronyms "name `IP` contains a capitalized acronym"
 regex/1.3.2/src/pikevm.rs:88:5 clippy::too_many_arguments "this function has too many arguments (8/7)"
 regex/1.3.2/src/prog.rs:102:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
 regex/1.3.2/src/prog.rs:113:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
@@ -2967,12 +2960,12 @@ regex/1.3.2/src/utf8.rs:85:19 clippy::cast_lossless "casting `u8` to `u32` may b
 regex/1.3.2/src/utf8.rs:92:23 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
 regex/1.3.2/src/utf8.rs:92:9 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
 regex/1.3.2/src/utf8.rs:97:16 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
-ripgrep/12.1.1//home/matthias/.rustup/toolchains/nightly-2020-12-20-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/std/src/macros.rs:14:27 clippy::match_same_arms "this `match` has identical arm bodies"
-ripgrep/12.1.1//home/matthias/.rustup/toolchains/nightly-2020-12-20-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/std/src/macros.rs:14:27 clippy::match_same_arms "this `match` has identical arm bodies"
-ripgrep/12.1.1//home/matthias/.rustup/toolchains/nightly-2020-12-20-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/std/src/macros.rs:14:27 clippy::match_same_arms "this `match` has identical arm bodies"
-ripgrep/12.1.1//home/matthias/.rustup/toolchains/nightly-2020-12-20-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/std/src/macros.rs:14:27 clippy::match_same_arms "this `match` has identical arm bodies"
+ripgrep/12.1.1//home/matthias/.rustup/toolchains/nightly-2021-01-15-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/std/src/macros.rs:14:27 clippy::match_same_arms "this `match` has identical arm bodies"
+ripgrep/12.1.1//home/matthias/.rustup/toolchains/nightly-2021-01-15-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/std/src/macros.rs:14:27 clippy::match_same_arms "this `match` has identical arm bodies"
+ripgrep/12.1.1//home/matthias/.rustup/toolchains/nightly-2021-01-15-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/std/src/macros.rs:14:27 clippy::match_same_arms "this `match` has identical arm bodies"
+ripgrep/12.1.1//home/matthias/.rustup/toolchains/nightly-2021-01-15-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/std/src/macros.rs:14:27 clippy::match_same_arms "this `match` has identical arm bodies"
 ripgrep/12.1.1/build.rs:133:19 clippy::option_as_ref_deref "called `.as_ref().map(|x| &**x)` on an Option value. This can be done more directly by calling `githash.as_deref()` instead"
-ripgrep/12.1.1/build.rs:18:18 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+ripgrep/12.1.1/build.rs:18:18 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 ripgrep/12.1.1/build.rs:225:14 clippy::redundant_closure_for_method_calls "redundant closure found"
 ripgrep/12.1.1/build.rs:92:19 clippy::option_as_ref_deref "called `.as_ref().map(|x| &**x)` on an Option value. This can be done more directly by calling `githash.as_deref()` instead"
 ripgrep/12.1.1/crates/core/app.rs:1408:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
@@ -2985,6 +2978,8 @@ ripgrep/12.1.1/crates/core/app.rs:156:39 clippy::doc_markdown "you should put `c
 ripgrep/12.1.1/crates/core/app.rs:156:39 clippy::doc_markdown "you should put `clap::Arg` between ticks in the documentation"
 ripgrep/12.1.1/crates/core/app.rs:156:5 clippy::doc_markdown "you should put `RGArg` between ticks in the documentation"
 ripgrep/12.1.1/crates/core/app.rs:156:5 clippy::doc_markdown "you should put `RGArg` between ticks in the documentation"
+ripgrep/12.1.1/crates/core/app.rs:164:12 clippy::upper_case_acronyms "name `RGArg` contains a capitalized acronym"
+ripgrep/12.1.1/crates/core/app.rs:164:12 clippy::upper_case_acronyms "name `RGArg` contains a capitalized acronym"
 ripgrep/12.1.1/crates/core/app.rs:1668:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
 ripgrep/12.1.1/crates/core/app.rs:1668:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
 ripgrep/12.1.1/crates/core/app.rs:1669:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
@@ -2993,6 +2988,8 @@ ripgrep/12.1.1/crates/core/app.rs:1821:5 clippy::items_after_statements "adding
 ripgrep/12.1.1/crates/core/app.rs:1821:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
 ripgrep/12.1.1/crates/core/app.rs:1822:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
 ripgrep/12.1.1/crates/core/app.rs:1822:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+ripgrep/12.1.1/crates/core/app.rs:212:10 clippy::upper_case_acronyms "name `RGArgKind` contains a capitalized acronym"
+ripgrep/12.1.1/crates/core/app.rs:212:10 clippy::upper_case_acronyms "name `RGArgKind` contains a capitalized acronym"
 ripgrep/12.1.1/crates/core/app.rs:2999:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
 ripgrep/12.1.1/crates/core/app.rs:2999:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
 ripgrep/12.1.1/crates/core/app.rs:3000:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
@@ -3012,7 +3009,6 @@ ripgrep/12.1.1/crates/core/app.rs:87:5 clippy::if_not_else "unnecessary boolean
 ripgrep/12.1.1/crates/core/args.rs:1143:22 clippy::unused_self "unused `self` argument"
 ripgrep/12.1.1/crates/core/args.rs:11:1 clippy::single_component_path_imports "this import is redundant"
 ripgrep/12.1.1/crates/core/args.rs:1209:74 clippy::if_same_then_else "this `if` has identical blocks"
-ripgrep/12.1.1/crates/core/args.rs:1209:74 clippy::if_same_then_else "this `if` has identical blocks"
 ripgrep/12.1.1/crates/core/args.rs:1282:13 clippy::similar_names "binding's name is too similar to existing binding"
 ripgrep/12.1.1/crates/core/args.rs:1430:22 clippy::unused_self "unused `self` argument"
 ripgrep/12.1.1/crates/core/args.rs:1438:21 clippy::doc_markdown "you should put `OsStr` between ticks in the documentation"
@@ -3025,10 +3021,12 @@ ripgrep/12.1.1/crates/core/args.rs:287:13 clippy::similar_names "binding's name
 ripgrep/12.1.1/crates/core/args.rs:33:1 clippy::single_component_path_imports "this import is redundant"
 ripgrep/12.1.1/crates/core/args.rs:34:1 clippy::single_component_path_imports "this import is redundant"
 ripgrep/12.1.1/crates/core/args.rs:35:1 clippy::single_component_path_imports "this import is redundant"
+ripgrep/12.1.1/crates/core/args.rs:369:5 clippy::upper_case_acronyms "name `JSON` contains a capitalized acronym"
 ripgrep/12.1.1/crates/core/args.rs:410:14 clippy::trivially_copy_pass_by_ref "this argument (2 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
 ripgrep/12.1.1/crates/core/args.rs:475:18 clippy::match_same_arms "this `match` has identical arm bodies"
 ripgrep/12.1.1/crates/core/args.rs:512:19 clippy::doc_markdown "you should put `ArgMatches` between ticks in the documentation"
 ripgrep/12.1.1/crates/core/args.rs:549:16 clippy::wrong_self_convention "methods called `to_*` usually take self by reference; consider choosing a less ambiguous name"
+ripgrep/12.1.1/crates/core/args.rs:71:5 clippy::upper_case_acronyms "name `PCRE2Version` contains a capitalized acronym"
 ripgrep/12.1.1/crates/core/args.rs:76:18 clippy::trivially_copy_pass_by_ref "this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
 ripgrep/12.1.1/crates/core/args.rs:77:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
 ripgrep/12.1.1/crates/core/args.rs:923:42 clippy::doc_markdown "you should put `BinaryDetection::quit` between ticks in the documentation"
@@ -3045,6 +3043,7 @@ ripgrep/12.1.1/crates/core/messages.rs:62:1 clippy::module_name_repetitions "ite
 ripgrep/12.1.1/crates/core/path_printer.rs:27:1 clippy::module_name_repetitions "item name starts with its containing module's name"
 ripgrep/12.1.1/crates/core/path_printer.rs:89:9 clippy::if_not_else "unnecessary boolean `not` operation"
 ripgrep/12.1.1/crates/core/search.rs:185:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+ripgrep/12.1.1/crates/core/search.rs:224:5 clippy::upper_case_acronyms "name `JSON` contains a capitalized acronym"
 ripgrep/12.1.1/crates/core/search.rs:292:9 clippy::write_with_newline "using `write!()` with a format string that ends in a single newline"
 ripgrep/12.1.1/crates/core/search.rs:311:1 clippy::module_name_repetitions "item name starts with its containing module's name"
 ripgrep/12.1.1/crates/core/search.rs:377:12 clippy::nonminimal_bool "this boolean expression can be simplified"
@@ -3064,13 +3063,14 @@ ripgrep/12.1.1/crates/core/search.rs:533:5 clippy::cast_precision_loss "casting
 ripgrep/12.1.1/crates/core/subject.rs:20:1 clippy::module_name_repetitions "item name starts with its containing module's name"
 ripgrep/12.1.1/crates/core/subject.rs:4:1 clippy::single_component_path_imports "this import is redundant"
 syn/1.0.54/build.rs:1:null clippy::cargo_common_metadata "package `syn` is missing `package.keywords` metadata"
-syn/1.0.54/build.rs:1:null clippy::multiple_crate_versions "could not read cargo metadata: failed to run `cargo metadata`:  Downloading crates ...\n  Downloaded dtoa v0.4.7\n  Downloaded anyhow v1.0.37\n  Downloaded syn-test-suite v0.0.0\nerror: failed to verify the checksum of `syn-test-suite v0.0.0`"
+syn/1.0.54/build.rs:1:null clippy::multiple_crate_versions "could not read cargo metadata: `cargo metadata` exited with an error:  Downloading crates ...\n  Downloaded syn-test-suite v0.0.0\nerror: failed to verify the checksum of `syn-test-suite v0.0.0`"
 syn/1.0.54/src/lib.rs:1:null clippy::cargo_common_metadata "package `syn` is missing `package.keywords` metadata"
-syn/1.0.54/src/lib.rs:1:null clippy::multiple_crate_versions "could not read cargo metadata: failed to run `cargo metadata`:  Downloading crates ...\n  Downloaded syn-test-suite v0.0.0\nerror: failed to verify the checksum of `syn-test-suite v0.0.0`"
+syn/1.0.54/src/lib.rs:1:null clippy::multiple_crate_versions "could not read cargo metadata: `cargo metadata` exited with an error:  Downloading crates ...\n  Downloaded syn-test-suite v0.0.0\nerror: failed to verify the checksum of `syn-test-suite v0.0.0`"
 syn/1.0.54/src/lit.rs:1397:40 clippy::redundant_else "redundant else block"
 syn/1.0.54/src/lit.rs:1405:28 clippy::redundant_else "redundant else block"
 syn/1.0.54/src/lit.rs:1485:32 clippy::redundant_else "redundant else block"
 unicode-xid/0.2.1/src/lib.rs:1:null clippy::cargo_common_metadata "package `unicode-xid` is missing `package.categories` metadata"
+unicode-xid/0.2.1/src/lib.rs:56:11 clippy::upper_case_acronyms "name `UnicodeXID` contains a capitalized acronym"
 unicode-xid/0.2.1/src/lib.rs:57:64 clippy::doc_markdown "you should put `XID_Start` between ticks in the documentation"
 unicode-xid/0.2.1/src/lib.rs:60:10 clippy::doc_markdown "you should put `XID_Start` between ticks in the documentation"
 unicode-xid/0.2.1/src/lib.rs:62:27 clippy::doc_markdown "you should put `ID_Start` between ticks in the documentation"
@@ -3086,12 +3086,12 @@ xsv/0.13.0/src/cmd/cat.rs:42:1 clippy::struct_excessive_bools "more than 3 bools
 xsv/0.13.0/src/cmd/cat.rs:53:9 clippy::similar_names "binding's name is too similar to existing binding"
 xsv/0.13.0/src/cmd/cat.rs:7:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
 xsv/0.13.0/src/cmd/count.rs:32:9 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/cmd/count.rs:38:9 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+xsv/0.13.0/src/cmd/count.rs:38:9 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 xsv/0.13.0/src/cmd/count.rs:42:33 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
 xsv/0.13.0/src/cmd/count.rs:50:5 clippy::unit_arg "passing a unit value to a function"
 xsv/0.13.0/src/cmd/count.rs:7:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
 xsv/0.13.0/src/cmd/fixlengths.rs:45:9 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/cmd/fixlengths.rs:50:18 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+xsv/0.13.0/src/cmd/fixlengths.rs:50:18 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 xsv/0.13.0/src/cmd/fixlengths.rs:62:30 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
 xsv/0.13.0/src/cmd/fixlengths.rs:9:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
 xsv/0.13.0/src/cmd/flatten.rs:10:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
@@ -3104,7 +3104,7 @@ xsv/0.13.0/src/cmd/frequency.rs:149:43 clippy::cast_possible_truncation "casting
 xsv/0.13.0/src/cmd/frequency.rs:15:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
 xsv/0.13.0/src/cmd/frequency.rs:169:13 clippy::similar_names "binding's name is too similar to existing binding"
 xsv/0.13.0/src/cmd/frequency.rs:176:17 clippy::if_not_else "unnecessary boolean `not` operation"
-xsv/0.13.0/src/cmd/frequency.rs:178:24 clippy::collapsible_if "this `else { if .. }` block can be collapsed"
+xsv/0.13.0/src/cmd/frequency.rs:178:24 clippy::collapsible_else_if "this `else { if .. }` block can be collapsed"
 xsv/0.13.0/src/cmd/frequency.rs:77:9 clippy::similar_names "binding's name is too similar to existing binding"
 xsv/0.13.0/src/cmd/frequency.rs:93:31 clippy::explicit_into_iter_loop "it is more concise to loop over containers instead of using explicit iteration methods"
 xsv/0.13.0/src/cmd/headers.rs:43:9 clippy::similar_names "binding's name is too similar to existing binding"
@@ -3136,6 +3136,7 @@ xsv/0.13.0/src/cmd/join.rs:426:13 clippy::if_not_else "unnecessary boolean `not`
 xsv/0.13.0/src/cmd/join.rs:77:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
 xsv/0.13.0/src/cmd/join.rs:94:9 clippy::similar_names "binding's name is too similar to existing binding"
 xsv/0.13.0/src/cmd/partition.rs:105:22 clippy::similar_names "binding's name is too similar to existing binding"
+xsv/0.13.0/src/cmd/partition.rs:106:22 clippy::redundant_slicing "redundant slicing of the whole range"
 xsv/0.13.0/src/cmd/partition.rs:139:13 clippy::redundant_field_names "redundant field names in struct initialization"
 xsv/0.13.0/src/cmd/partition.rs:15:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
 xsv/0.13.0/src/cmd/partition.rs:169:9 clippy::if_not_else "unnecessary boolean `not` operation"
@@ -3145,7 +3146,7 @@ xsv/0.13.0/src/cmd/sample.rs:105:44 clippy::cast_possible_truncation "casting `u
 xsv/0.13.0/src/cmd/sample.rs:115:21 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
 xsv/0.13.0/src/cmd/sample.rs:11:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
 xsv/0.13.0/src/cmd/sample.rs:51:9 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/cmd/sample.rs:58:19 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+xsv/0.13.0/src/cmd/sample.rs:58:19 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 xsv/0.13.0/src/cmd/sample.rs:69:9 clippy::match_wildcard_for_single_variants "wildcard match will miss any future added variants"
 xsv/0.13.0/src/cmd/sample.rs:75:16 clippy::explicit_into_iter_loop "it is more concise to loop over containers instead of using explicit iteration methods"
 xsv/0.13.0/src/cmd/sample.rs:91:42 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
@@ -3194,11 +3195,11 @@ xsv/0.13.0/src/cmd/stats.rs:297:25 clippy::option_map_unit_fn "called `map(f)` o
 xsv/0.13.0/src/cmd/stats.rs:301:21 clippy::option_map_unit_fn "called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`"
 xsv/0.13.0/src/cmd/stats.rs:302:21 clippy::option_map_unit_fn "called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`"
 xsv/0.13.0/src/cmd/stats.rs:308:18 clippy::wrong_self_convention "methods called `to_*` usually take self by reference; consider choosing a less ambiguous name"
-xsv/0.13.0/src/cmd/stats.rs:318:9 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+xsv/0.13.0/src/cmd/stats.rs:318:9 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 xsv/0.13.0/src/cmd/stats.rs:322:45 clippy::redundant_closure_for_method_calls "redundant closure found"
-xsv/0.13.0/src/cmd/stats.rs:322:9 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+xsv/0.13.0/src/cmd/stats.rs:322:9 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 xsv/0.13.0/src/cmd/stats.rs:327:9 clippy::if_not_else "unnecessary boolean `not` operation"
-xsv/0.13.0/src/cmd/stats.rs:330:13 clippy::single_match_else "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`"
+xsv/0.13.0/src/cmd/stats.rs:330:13 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
 xsv/0.13.0/src/cmd/stats.rs:338:45 clippy::redundant_closure_for_method_calls "redundant closure found"
 xsv/0.13.0/src/cmd/stats.rs:402:16 clippy::redundant_pattern_matching "redundant pattern matching, consider using `is_ok()`"
 xsv/0.13.0/src/cmd/stats.rs:403:16 clippy::redundant_pattern_matching "redundant pattern matching, consider using `is_ok()`"
@@ -3243,7 +3244,7 @@ xsv/0.13.0/src/select.rs:280:20 clippy::len_zero "length comparison to zero"
 xsv/0.13.0/src/select.rs:29:13 clippy::redundant_field_names "redundant field names in struct initialization"
 xsv/0.13.0/src/select.rs:360:62 clippy::trivially_copy_pass_by_ref "this argument (8 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
 xsv/0.13.0/src/select.rs:360:9 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Option`"
-xsv/0.13.0/src/select.rs:375:9 clippy::stable_sort_primitive "used sort instead of sort_unstable to sort primitive type `usize`"
+xsv/0.13.0/src/select.rs:375:9 clippy::stable_sort_primitive "used `sort` on primitive type `usize`"
 xsv/0.13.0/src/select.rs:379:18 clippy::explicit_into_iter_loop "it is more concise to loop over containers instead of using explicit iteration methods"
 xsv/0.13.0/src/select.rs:416:5 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
 xsv/0.13.0/src/select.rs:419:9 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Option`"
@@ -3259,7 +3260,6 @@ xsv/0.13.0/src/util.rs:90:1 clippy::needless_lifetimes "explicit lifetimes given
 Stats
 
 clippy::clone_on_copy 1
-clippy::collapsible_if 1
 clippy::comparison_chain 1
 clippy::expect_fun_call 1
 clippy::explicit_deref_methods 1
@@ -3273,6 +3273,7 @@ clippy::or_fun_call 1
 clippy::precedence 1
 clippy::pub_enum_variant_names 1
 clippy::redundant_clone 1
+clippy::redundant_slicing 1
 clippy::same_item_push 1
 clippy::should_implement_trait 1
 clippy::stable_sort_primitive 1
@@ -3284,6 +3285,7 @@ clippy::while_let_on_iterator 1
 clippy::comparison_to_empty 2
 clippy::derive_hash_xor_eq 2
 clippy::expl_impl_clone_on_copy 2
+clippy::filter_map 2
 clippy::len_zero 2
 clippy::manual_non_exhaustive 2
 clippy::match_on_vec_items 2
@@ -3294,16 +3296,17 @@ clippy::redundant_pattern_matching 2
 clippy::type_complexity 2
 clippy::unnecessary_cast 2
 clippy::unused_unit 2
+clippy::vec_init_then_push 2
 clippy::write_with_newline 2
 clippy::filter_map_next 3
 clippy::fn_params_excessive_bools 3
+clippy::if_same_then_else 3
 clippy::mut_mut 3
 clippy::ptr_arg 3
 clippy::zero_ptr 3
-clippy::if_same_then_else 4
 clippy::let_underscore_drop 4
 clippy::too_many_arguments 4
-clippy::empty_enum 5
+clippy::collapsible_else_if 5
 clippy::explicit_iter_loop 5
 clippy::field_reassign_with_default 5
 clippy::identity_op 5
@@ -3311,16 +3314,18 @@ clippy::len_without_is_empty 5
 clippy::match_like_matches_macro 5
 clippy::needless_return 5
 clippy::new_without_default 5
+clippy::ptr_as_ptr 5
 clippy::manual_strip 6
 clippy::non_ascii_literal 6
 clippy::single_component_path_imports 6
+clippy::case_sensitive_file_extension_comparisons 7
 clippy::explicit_into_iter_loop 7
 clippy::map_clone 7
 clippy::option_map_unit_fn 7
 clippy::range_plus_one 7
 clippy::invalid_upcast_comparisons 8
+clippy::needless_question_mark 8
 clippy::wrong_self_convention 8
-clippy::find_map 9
 clippy::manual_range_contains 10
 clippy::match_wildcard_for_single_variants 10
 clippy::missing_safety_doc 10
@@ -3334,6 +3339,7 @@ clippy::linkedlist 14
 clippy::single_char_add_str 14
 clippy::default_trait_access 16
 clippy::needless_pass_by_value 18
+clippy::upper_case_acronyms 18
 clippy::cast_possible_wrap 19
 clippy::cast_sign_loss 19
 clippy::unnecessary_wraps 19
@@ -3345,7 +3351,6 @@ clippy::redundant_static_lifetimes 21
 clippy::cast_lossless 23
 clippy::trivially_copy_pass_by_ref 26
 clippy::redundant_else 29
-clippy::filter_map 31
 clippy::too_many_lines 31
 clippy::cast_precision_loss 35
 clippy::if_not_else 35

From 5b6a18362be15a693e202a592f4ae6bc4b2844f2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= <matthias.krueger@famsik.de>
Date: Sat, 23 Jan 2021 01:09:51 +0100
Subject: [PATCH 101/108] lintcheck: fix paths in the logs

---
 clippy_dev/src/lintcheck.rs |    2 +-
 lintcheck-logs/logs.txt     | 6506 +++++++++++++++++------------------
 2 files changed, 3254 insertions(+), 3254 deletions(-)

diff --git a/clippy_dev/src/lintcheck.rs b/clippy_dev/src/lintcheck.rs
index e2099ff98c836..785c692d3cb98 100644
--- a/clippy_dev/src/lintcheck.rs
+++ b/clippy_dev/src/lintcheck.rs
@@ -61,7 +61,7 @@ impl std::fmt::Display for ClippyWarning {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         writeln!(
             f,
-            r#"{}/{}/{}:{}:{} {} "{}""#,
+            r#"{}-{}/{}:{}:{} {} "{}""#,
             &self.crate_name, &self.crate_version, &self.file, &self.line, &self.column, &self.linttype, &self.message
         )
     }
diff --git a/lintcheck-logs/logs.txt b/lintcheck-logs/logs.txt
index f61e9b38775d2..e565691e0e396 100644
--- a/lintcheck-logs/logs.txt
+++ b/lintcheck-logs/logs.txt
@@ -1,3258 +1,3258 @@
 clippy 0.1.51 (c6701036b 2021-01-23)
 
-cargo/0.49.0//home/matthias/.rustup/toolchains/nightly-2021-01-15-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:393:34 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/build.rs:1:null clippy::cargo_common_metadata "package `cargo` is missing `package.categories` metadata"
-cargo/0.49.0/build.rs:1:null clippy::cargo_common_metadata "package `cargo` is missing `package.keywords` metadata"
-cargo/0.49.0/src/bin/cargo/cli.rs:104:34 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-cargo/0.49.0/src/bin/cargo/cli.rs:121:5 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
-cargo/0.49.0/src/bin/cargo/cli.rs:157:30 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/bin/cargo/cli.rs:184:41 clippy::cast_possible_truncation "casting `u64` to `u32` may truncate the value"
-cargo/0.49.0/src/bin/cargo/cli.rs:196:42 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/bin/cargo/cli.rs:200:39 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/bin/cargo/cli.rs:231:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
-cargo/0.49.0/src/bin/cargo/cli.rs:245:22 clippy::cast_possible_truncation "casting `u64` to `u32` may truncate the value"
-cargo/0.49.0/src/bin/cargo/cli.rs:247:47 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/bin/cargo/cli.rs:257:22 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/bin/cargo/cli.rs:26:20 clippy::redundant_else "redundant else block"
-cargo/0.49.0/src/bin/cargo/cli.rs:7:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/commands/bench.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/commands/bench.rs:76:59 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/bin/cargo/commands/build.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/commands/check.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/commands/clean.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/commands/doc.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/commands/fetch.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/commands/fix.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/commands/generate_lockfile.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/commands/git_checkout.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/commands/help.rs:20:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-cargo/0.49.0/src/bin/cargo/commands/init.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/commands/install.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/commands/install.rs:97:16 clippy::option_if_let_else "use Option::map_or instead of an if let/else"
-cargo/0.49.0/src/bin/cargo/commands/locate_project.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/commands/login.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/commands/metadata.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/commands/mod.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/commands/new.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/commands/new.rs:20:24 clippy::option_if_let_else "use Option::map_or instead of an if let/else"
-cargo/0.49.0/src/bin/cargo/commands/owner.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/commands/owner.rs:38:43 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/bin/cargo/commands/owner.rs:39:43 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/bin/cargo/commands/owner.rs:40:43 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/bin/cargo/commands/owner.rs:43:30 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/bin/cargo/commands/owner.rs:46:30 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/bin/cargo/commands/package.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/commands/pkgid.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/commands/publish.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/commands/publish.rs:40:47 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/bin/cargo/commands/read_manifest.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/commands/run.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/commands/rustc.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/commands/rustdoc.rs:3:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/commands/search.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/commands/test.rs:127:54 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/bin/cargo/commands/test.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/commands/tree.rs:149:49 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/bin/cargo/commands/tree.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/commands/uninstall.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/commands/update.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/commands/vendor.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/commands/vendor.rs:96:16 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
-cargo/0.49.0/src/bin/cargo/commands/verify_project.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/commands/version.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/commands/yank.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/commands/yank.rs:32:36 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/bin/cargo/commands/yank.rs:33:35 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/bin/cargo/commands/yank.rs:34:36 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/bin/cargo/commands/yank.rs:35:36 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/bin/cargo/main.rs:100:17 clippy::match_wildcard_for_single_variants "wildcard match will miss any future added variants"
-cargo/0.49.0/src/bin/cargo/main.rs:118:41 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/bin/cargo/main.rs:137:43 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/bin/cargo/main.rs:148:19 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-cargo/0.49.0/src/bin/cargo/main.rs:174:57 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/bin/cargo/main.rs:18:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/bin/cargo/main.rs:1:null clippy::cargo_common_metadata "package `cargo` is missing `package.categories` metadata"
-cargo/0.49.0/src/bin/cargo/main.rs:1:null clippy::cargo_common_metadata "package `cargo` is missing `package.keywords` metadata"
-cargo/0.49.0/src/bin/cargo/main.rs:1:null clippy::multiple_crate_versions "multiple versions for dependency `crossbeam-utils`: 0.6.6, 0.7.2"
-cargo/0.49.0/src/bin/cargo/main.rs:1:null clippy::multiple_crate_versions "multiple versions for dependency `hex`: 0.3.2, 0.4.0"
-cargo/0.49.0/src/bin/cargo/main.rs:1:null clippy::multiple_crate_versions "multiple versions for dependency `humantime`: 1.3.0, 2.0.0"
-cargo/0.49.0/src/bin/cargo/main.rs:72:22 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/bin/cargo/main.rs:94:13 clippy::match_wildcard_for_single_variants "wildcard match will miss any future added variants"
-cargo/0.49.0/src/bin/cargo/main.rs:96:41 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/bin/cargo/main.rs:98:60 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/compiler/build_config.rs:155:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
-cargo/0.49.0/src/cargo/core/compiler/build_config.rs:170:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/compiler/build_config.rs:175:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/compiler/build_config.rs:180:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/compiler/build_config.rs:186:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/compiler/build_config.rs:197:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/compiler/build_config.rs:205:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/compiler/build_config.rs:51:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/build_config.rs:69:48 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
-cargo/0.49.0/src/cargo/core/compiler/build_config.rs:96:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/build_context/mod.rs:44:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/build_context/mod.rs:83:20 clippy::doc_markdown "you should put `x86_64` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:108:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:121:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:149:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:411:9 clippy::needless_question_mark "Question mark operator is useless here"
-cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:420:69 clippy::doc_markdown "you should put `mode/target_kind` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:423:19 clippy::doc_markdown "you should put `CrateTypes` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:424:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:469:58 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:603:19 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:665:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:82:31 clippy::doc_markdown "you should put `FileType` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:83:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:84:9 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:96:31 clippy::doc_markdown "you should put `FileType` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/compiler/build_context/target_info.rs:98:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/compiler/build_plan.rs:4:9 clippy::doc_markdown "you should put `BuildPlan` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/compiler/build_plan.rs:5:66 clippy::doc_markdown "you should put `BuildPlan` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/compiler/build_plan.rs:66:40 clippy::ptr_arg "writing `&PathBuf` instead of `&Path` involves a new object where a slice will do."
-cargo/0.49.0/src/cargo/core/compiler/compilation.rs:150:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/compilation.rs:169:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/compilation.rs:185:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/compilation.rs:193:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/compiler/compilation.rs:194:49 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/compiler/compilation.rs:198:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/compilation.rs:314:16 clippy::doc_markdown "you should put `rustc_tool` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/compiler/compilation.rs:91:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/compile_kind.rs:118:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/compile_kind.rs:123:18 clippy::case_sensitive_file_extension_comparisons "case-sensitive file extension comparison"
-cargo/0.49.0/src/cargo/core/compiler/compile_kind.rs:147:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/compiler/compile_kind.rs:157:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/compiler/compile_kind.rs:29:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/compiler/compile_kind.rs:33:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/compiler/compile_kind.rs:49:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/compile_kind.rs:69:48 clippy::case_sensitive_file_extension_comparisons "case-sensitive file extension comparison"
-cargo/0.49.0/src/cargo/core/compiler/context/compilation_files.rs:204:9 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-cargo/0.49.0/src/cargo/core/compiler/context/compilation_files.rs:277:22 clippy::doc_markdown "you should put `OUT_DIR` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/compiler/context/compilation_files.rs:324:66 clippy::doc_markdown "you should put `FileType` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/compiler/context/compilation_files.rs:393:37 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/core/compiler/context/compilation_files.rs:426:71 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:125:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:125:5 clippy::too_many_lines "this function has too many lines (107/100)"
-cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:270:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:286:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:308:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:340:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:349:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:354:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:358:21 clippy::doc_markdown "you should put `RunCustomBuild` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:361:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:374:43 clippy::doc_markdown "you should put `RunCustomBuild` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:378:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:383:41 clippy::doc_markdown "you should put `RunCustomBuild` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:384:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:391:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:397:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:523:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:538:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:542:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:83:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/context/mod.rs:92:25 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-cargo/0.49.0/src/cargo/core/compiler/crate_type.rs:16:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/compiler/crate_type.rs:29:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/compiler/crate_type.rs:40:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/compiler/crate_type.rs:49:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/compiler/crate_type.rs:60:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:150:1 clippy::too_many_lines "this function has too many lines (230/100)"
-cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:353:56 clippy::manual_strip "stripping a prefix manually"
-cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:448:27 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
-cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:464:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:481:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:48:56 clippy::doc_markdown "you should put `RunCustomBuild` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:561:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:567:20 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:576:28 clippy::shadow_unrelated "`mut value` is being shadowed"
-cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:606:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:688:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:756:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:762:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:762:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
-cargo/0.49.0/src/cargo/core/compiler/custom_build.rs:823:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1021:51 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1656:16 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1664:5 clippy::field_reassign_with_default "field assignment outside of initializer for an instance created with Default::default()"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1787:5 clippy::similar_names "binding's name is too similar to existing binding"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1795:5 clippy::field_reassign_with_default "field assignment outside of initializer for an instance created with Default::default()"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1882:17 clippy::similar_names "binding's name is too similar to existing binding"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1894:17 clippy::similar_names "binding's name is too similar to existing binding"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1906:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1917:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1923:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1956:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1962:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1963:22 clippy::cast_possible_truncation "casting `usize` to `u8` may truncate the value"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1964:22 clippy::cast_possible_truncation "casting `usize` to `u8` may truncate the value"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1965:22 clippy::cast_possible_truncation "casting `usize` to `u8` may truncate the value"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1966:22 clippy::cast_possible_truncation "casting `usize` to `u8` may truncate the value"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1980:17 clippy::similar_names "binding's name is too similar to existing binding"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1980:24 clippy::manual_strip "stripping a prefix manually"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:1986:17 clippy::similar_names "binding's name is too similar to existing binding"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:2016:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:61:5 clippy::doc_markdown "you should put `CompileMode` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:63:12 clippy::doc_markdown "you should put `CompileKind` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:67:7 clippy::doc_markdown "you should put `CARGO_DEFAULT_LIB_METADATA[^4` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:68:5 clippy::doc_markdown "you should put `package_id` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:71:19 clippy::doc_markdown "you should put `test/bench/for_host/edition` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:755:52 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:77:5 clippy::doc_markdown "you should put `is_std` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:816:5 clippy::too_many_lines "this function has too many lines (127/100)"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:863:64 clippy::similar_names "binding's name is too similar to existing binding"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:875:33 clippy::similar_names "binding's name is too similar to existing binding"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:876:32 clippy::similar_names "binding's name is too similar to existing binding"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:896:30 clippy::similar_names "binding's name is too similar to existing binding"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:897:30 clippy::similar_names "binding's name is too similar to existing binding"
-cargo/0.49.0/src/cargo/core/compiler/fingerprint.rs:991:37 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:12:5 clippy::doc_markdown "you should put `src/librustc_jobserver/lib.rs` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:329:13 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:332:23 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
-cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:34:53 clippy::doc_markdown "you should put `NeedsToken` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:35:6 clippy::doc_markdown "you should put `ReleaseToken` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:37:6 clippy::doc_markdown "you should put `NeedsToken` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:40:5 clippy::doc_markdown "you should put `NeedsToken` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:40:56 clippy::doc_markdown "you should put `NeedsToken` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:43:6 clippy::doc_markdown "you should put `ReleaseToken` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:748:16 clippy::collapsible_else_if "this `else { if .. }` block can be collapsed"
-cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:749:13 clippy::if_not_else "unnecessary boolean `not` operation"
-cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:786:26 clippy::unused_self "unused `self` argument"
-cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:81:61 clippy::doc_markdown "you should put `DrainState` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:865:13 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:871:13 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:890:9 clippy::unused_self "unused `self` argument"
-cargo/0.49.0/src/cargo/core/compiler/job_queue.rs:93:24 clippy::doc_markdown "you should put `JobQueue` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/compiler/links.rs:8:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-cargo/0.49.0/src/cargo/core/compiler/mod.rs:1016:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/mod.rs:1094:19 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/compiler/mod.rs:1131:1 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
-cargo/0.49.0/src/cargo/core/compiler/mod.rs:1268:34 clippy::case_sensitive_file_extension_comparisons "case-sensitive file extension comparison"
-cargo/0.49.0/src/cargo/core/compiler/mod.rs:1277:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/core/compiler/mod.rs:179:1 clippy::too_many_lines "this function has too many lines (162/100)"
-cargo/0.49.0/src/cargo/core/compiler/mod.rs:198:78 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/compiler/mod.rs:201:25 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-cargo/0.49.0/src/cargo/core/compiler/mod.rs:267:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/core/compiler/mod.rs:324:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/core/compiler/mod.rs:364:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/core/compiler/mod.rs:364:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
-cargo/0.49.0/src/cargo/core/compiler/mod.rs:392:45 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/compiler/mod.rs:415:23 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-cargo/0.49.0/src/cargo/core/compiler/mod.rs:464:18 clippy::ptr_arg "writing `&PathBuf` instead of `&Path` involves a new object where a slice will do."
-cargo/0.49.0/src/cargo/core/compiler/mod.rs:488:61 clippy::ptr_arg "writing `&PathBuf` instead of `&Path` involves a new object where a slice will do."
-cargo/0.49.0/src/cargo/core/compiler/mod.rs:667:15 clippy::similar_names "binding's name is too similar to existing binding"
-cargo/0.49.0/src/cargo/core/compiler/mod.rs:693:1 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
-cargo/0.49.0/src/cargo/core/compiler/mod.rs:725:42 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/core/compiler/mod.rs:736:1 clippy::too_many_lines "this function has too many lines (141/100)"
-cargo/0.49.0/src/cargo/core/compiler/mod.rs:73:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/mod.rs:777:12 clippy::if_not_else "unnecessary boolean `not` operation"
-cargo/0.49.0/src/cargo/core/compiler/mod.rs:873:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/core/compiler/output_depinfo.rs:41:13 clippy::match_wildcard_for_single_variants "wildcard match will miss any future added variants"
-cargo/0.49.0/src/cargo/core/compiler/rustdoc.rs:16:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/core/compiler/rustdoc.rs:57:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/core/compiler/rustdoc.rs:72:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/standard_lib.rs:134:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/standard_lib.rs:16:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/compiler/standard_lib.rs:30:28 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/compiler/standard_lib.rs:34:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/timings.rs:16:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
-cargo/0.49.0/src/cargo/core/compiler/timings.rs:192:64 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
-cargo/0.49.0/src/cargo/core/compiler/timings.rs:212:58 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
-cargo/0.49.0/src/cargo/core/compiler/timings.rs:234:13 clippy::let_underscore_drop "non-binding `let` on a type that implements `Drop`"
-cargo/0.49.0/src/cargo/core/compiler/timings.rs:355:13 clippy::cast_possible_truncation "casting `f64` to `u32` may truncate the value"
-cargo/0.49.0/src/cargo/core/compiler/timings.rs:355:13 clippy::cast_sign_loss "casting `f64` to `u32` may lose the sign of the value"
-cargo/0.49.0/src/cargo/core/compiler/timings.rs:397:38 clippy::cast_possible_truncation "casting `f64` to `u32` may truncate the value"
-cargo/0.49.0/src/cargo/core/compiler/timings.rs:397:38 clippy::cast_sign_loss "casting `f64` to `u32` may lose the sign of the value"
-cargo/0.49.0/src/cargo/core/compiler/timings.rs:484:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/core/compiler/timings.rs:605:38 clippy::doc_markdown "you should put `rmeta_time` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/compiler/timings.rs:605:50 clippy::doc_markdown "you should put `codegen_time` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/compiler/timings.rs:641:26 clippy::non_ascii_literal "literal non-ASCII character detected"
-cargo/0.49.0/src/cargo/core/compiler/unit.rs:100:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/compiler/unit.rs:151:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/core/compiler/unit.rs:161:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/compiler/unit.rs:35:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/core/compiler/unit_dependencies.rs:154:29 clippy::doc_markdown "you should put `state.unit_dependencies` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/compiler/unit_dependencies.rs:213:1 clippy::too_many_lines "this function has too many lines (110/100)"
-cargo/0.49.0/src/cargo/core/compiler/unit_dependencies.rs:52:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/unit_dependencies.rs:52:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-cargo/0.49.0/src/cargo/core/compiler/unit_graph.rs:65:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/compiler/unit_graph.rs:65:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-cargo/0.49.0/src/cargo/core/dependency.rs:157:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/dependency.rs:182:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/dependency.rs:203:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/dependency.rs:224:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/dependency.rs:23:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
-cargo/0.49.0/src/cargo/core/dependency.rs:248:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/dependency.rs:270:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/dependency.rs:274:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/dependency.rs:278:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/dependency.rs:287:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/dependency.rs:291:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/dependency.rs:305:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/dependency.rs:311:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/dependency.rs:319:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/dependency.rs:337:75 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/dependency.rs:397:56 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/dependency.rs:403:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/dependency.rs:408:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/dependency.rs:415:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/dependency.rs:419:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/dependency.rs:424:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/dependency.rs:428:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/dependency.rs:433:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/dependency.rs:438:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/dependency.rs:443:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/dependency.rs:449:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/dependency.rs:450:9 clippy::if_not_else "unnecessary `!=` operation"
-cargo/0.49.0/src/cargo/core/features.rs:119:17 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/features.rs:229:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/features.rs:274:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/features.rs:278:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/features.rs:306:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/features.rs:338:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
-cargo/0.49.0/src/cargo/core/features.rs:362:25 clippy::option_option "consider using `Option<T>` instead of `Option<Option<T>>` or a custom enum if you need to distinguish all 3 cases"
-cargo/0.49.0/src/cargo/core/features.rs:380:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/features.rs:401:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/core/features.rs:409:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/core/features.rs:412:45 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/features.rs:416:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/core/features.rs:419:45 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/features.rs:424:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/core/features.rs:431:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/core/features.rs:477:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/features.rs:509:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/features.rs:518:5 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
-cargo/0.49.0/src/cargo/core/features.rs:542:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/features.rs:543:37 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/features.rs:547:60 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/features.rs:556:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-cargo/0.49.0/src/cargo/core/features.rs:563:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-cargo/0.49.0/src/cargo/core/manifest.rs:116:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
-cargo/0.49.0/src/cargo/core/manifest.rs:118:58 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/manifest.rs:130:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
-cargo/0.49.0/src/cargo/core/manifest.rs:143:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:159:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:162:34 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/manifest.rs:169:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:17:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/cargo/core/manifest.rs:189:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
-cargo/0.49.0/src/cargo/core/manifest.rs:215:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:222:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:22:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-cargo/0.49.0/src/cargo/core/manifest.rs:360:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:407:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:410:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:413:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:416:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:419:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:422:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:425:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:431:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:438:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:444:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:447:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:450:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:453:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:456:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:459:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:462:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:466:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:470:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:477:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:481:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:488:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/manifest.rs:512:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:516:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:520:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:524:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:528:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:538:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:557:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:561:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:565:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:569:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:577:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:581:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:588:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:617:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:632:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:648:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:659:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:66:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-cargo/0.49.0/src/cargo/core/manifest.rs:670:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:693:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:708:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:723:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:726:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:729:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:735:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:738:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:741:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:744:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:747:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:751:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:754:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:757:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:760:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:763:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:767:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:776:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:780:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:787:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:798:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:800:56 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/manifest.rs:805:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:809:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:818:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:823:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:828:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:831:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:834:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:839:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:85:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/core/manifest.rs:888:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/manifest.rs:936:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/package.rs:1075:28 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/package.rs:160:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/package.rs:170:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/package.rs:174:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/package.rs:182:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/package.rs:186:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/package.rs:190:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/package.rs:194:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/package.rs:198:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/package.rs:202:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/package.rs:206:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/package.rs:210:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/package.rs:217:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/package.rs:221:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/package.rs:222:35 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/package.rs:226:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/package.rs:227:35 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/package.rs:230:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/package.rs:239:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/package.rs:249:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/package.rs:287:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/core/package.rs:385:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/package.rs:421:5 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
-cargo/0.49.0/src/cargo/core/package.rs:425:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/package.rs:452:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/package.rs:453:60 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/package.rs:459:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/package.rs:473:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/package.rs:587:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/package.rs:588:9 clippy::needless_question_mark "Question mark operator is useless here"
-cargo/0.49.0/src/cargo/core/package.rs:682:46 clippy::cast_possible_truncation "casting `f64` to `u64` may truncate the value"
-cargo/0.49.0/src/cargo/core/package.rs:682:46 clippy::cast_sign_loss "casting `f64` to `u64` may lose the sign of the value"
-cargo/0.49.0/src/cargo/core/package.rs:682:63 clippy::cast_possible_truncation "casting `f64` to `u64` may truncate the value"
-cargo/0.49.0/src/cargo/core/package.rs:682:63 clippy::cast_sign_loss "casting `f64` to `u64` may lose the sign of the value"
-cargo/0.49.0/src/cargo/core/package.rs:731:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/package.rs:790:13 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-cargo/0.49.0/src/cargo/core/package.rs:988:9 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-cargo/0.49.0/src/cargo/core/package_id.rs:115:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/package_id.rs:124:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/package_id.rs:139:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/package_id.rs:142:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/package_id.rs:145:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/package_id.rs:149:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/package_id.rs:157:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/package_id.rs:161:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/package_id.rs:169:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/package_id.rs:174:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/core/package_id_spec.rs:101:39 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/package_id_spec.rs:143:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/package_id_spec.rs:147:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/package_id_spec.rs:151:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/package_id_spec.rs:160:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/package_id_spec.rs:179:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/package_id_spec.rs:212:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/core/package_id_spec.rs:231:9 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-cargo/0.49.0/src/cargo/core/package_id_spec.rs:51:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/package_id_spec.rs:77:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/package_id_spec.rs:88:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/profiles.rs:1004:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/profiles.rs:1014:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/profiles.rs:1018:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/profiles.rs:1028:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/profiles.rs:106:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/core/profiles.rs:143:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
-cargo/0.49.0/src/cargo/core/profiles.rs:286:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/profiles.rs:294:40 clippy::if_not_else "unnecessary boolean `not` operation"
-cargo/0.49.0/src/cargo/core/profiles.rs:30:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/profiles.rs:342:25 clippy::shadow_unrelated "`maker` is being shadowed"
-cargo/0.49.0/src/cargo/core/profiles.rs:370:41 clippy::unused_self "unused `self` argument"
-cargo/0.49.0/src/cargo/core/profiles.rs:370:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/profiles.rs:372:9 clippy::field_reassign_with_default "field assignment outside of initializer for an instance created with Default::default()"
-cargo/0.49.0/src/cargo/core/profiles.rs:382:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/profiles.rs:383:28 clippy::if_not_else "unnecessary boolean `not` operation"
-cargo/0.49.0/src/cargo/core/profiles.rs:397:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/profiles.rs:405:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/profiles.rs:607:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
-cargo/0.49.0/src/cargo/core/profiles.rs:909:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/profiles.rs:923:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/profiles.rs:934:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/profiles.rs:987:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/registry.rs:111:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/registry.rs:127:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/registry.rs:168:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/registry.rs:19:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/registry.rs:240:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/registry.rs:26:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/registry.rs:344:49 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/registry.rs:369:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/registry.rs:424:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/registry.rs:49:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-cargo/0.49.0/src/cargo/core/registry.rs:520:17 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-cargo/0.49.0/src/cargo/core/registry.rs:763:53 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/registry.rs:765:53 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/registry.rs:807:14 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/registry.rs:814:53 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/resolver/conflict_cache.rs:197:29 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/resolver/conflict_cache.rs:41:38 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
-cargo/0.49.0/src/cargo/core/resolver/context.rs:274:53 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/resolver/context.rs:42:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/core/resolver/context.rs:74:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/resolver/encode.rs:156:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/resolver/encode.rs:156:5 clippy::too_many_lines "this function has too many lines (164/100)"
-cargo/0.49.0/src/cargo/core/resolver/encode.rs:339:17 clippy::match_wildcard_for_single_variants "wildcard match will miss any future added variants"
-cargo/0.49.0/src/cargo/core/resolver/encode.rs:438:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/core/resolver/encode.rs:449:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/core/resolver/encode.rs:529:34 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/resolver/encode.rs:602:59 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/resolver/encode.rs:623:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/core/resolver/encode.rs:652:27 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-cargo/0.49.0/src/cargo/core/resolver/encode.rs:674:51 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/resolver/errors.rs:103:22 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/resolver/errors.rs:104:22 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/resolver/errors.rs:206:9 clippy::if_not_else "unnecessary boolean `not` operation"
-cargo/0.49.0/src/cargo/core/resolver/errors.rs:257:45 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/resolver/errors.rs:27:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/resolver/errors.rs:305:17 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
-cargo/0.49.0/src/cargo/core/resolver/errors.rs:70:1 clippy::too_many_lines "this function has too many lines (207/100)"
-cargo/0.49.0/src/cargo/core/resolver/features.rs:104:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/core/resolver/features.rs:111:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/resolver/features.rs:162:56 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/resolver/features.rs:179:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-cargo/0.49.0/src/cargo/core/resolver/features.rs:186:23 clippy::doc_markdown "you should put `RequestedFeatures` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/resolver/features.rs:187:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/resolver/features.rs:199:23 clippy::doc_markdown "you should put `RequestedFeatures` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/resolver/features.rs:200:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/resolver/features.rs:221:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/resolver/features.rs:231:21 clippy::doc_markdown "you should put `pkg_id/is_build` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/resolver/features.rs:233:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/resolver/features.rs:247:58 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/resolver/features.rs:278:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/resolver/features.rs:394:27 clippy::doc_markdown "you should put `FeatureValue` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/resolver/features.rs:460:19 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-cargo/0.49.0/src/cargo/core/resolver/features.rs:480:24 clippy::doc_markdown "you should put `FeatureValues` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/resolver/features.rs:496:24 clippy::doc_markdown "you should put `FeatureValues` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/resolver/features.rs:58:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-cargo/0.49.0/src/cargo/core/resolver/features.rs:67:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
-cargo/0.49.0/src/cargo/core/resolver/mod.rs:1017:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/core/resolver/mod.rs:1045:57 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/resolver/mod.rs:122:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/resolver/mod.rs:142:44 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/resolver/mod.rs:180:1 clippy::too_many_lines "this function has too many lines (225/100)"
-cargo/0.49.0/src/cargo/core/resolver/mod.rs:311:17 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-cargo/0.49.0/src/cargo/core/resolver/mod.rs:421:52 clippy::filter_map_next "called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find_map(..)` instead."
-cargo/0.49.0/src/cargo/core/resolver/mod.rs:457:69 clippy::filter_map_next "called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find_map(..)` instead."
-cargo/0.49.0/src/cargo/core/resolver/mod.rs:470:37 clippy::similar_names "binding's name is too similar to existing binding"
-cargo/0.49.0/src/cargo/core/resolver/mod.rs:607:11 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
-cargo/0.49.0/src/cargo/core/resolver/mod.rs:631:21 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-cargo/0.49.0/src/cargo/core/resolver/mod.rs:942:15 clippy::if_not_else "unnecessary boolean `not` operation"
-cargo/0.49.0/src/cargo/core/resolver/mod.rs:988:20 clippy::redundant_else "redundant else block"
-cargo/0.49.0/src/cargo/core/resolver/resolve.rs:120:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/resolver/resolve.rs:132:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/resolver/resolve.rs:199:24 clippy::redundant_else "redundant else block"
-cargo/0.49.0/src/cargo/core/resolver/resolve.rs:235:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/resolver/resolve.rs:239:5 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
-cargo/0.49.0/src/cargo/core/resolver/resolve.rs:255:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/resolver/resolve.rs:259:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/resolver/resolve.rs:263:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/resolver/resolve.rs:269:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/resolver/resolve.rs:273:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/resolver/resolve.rs:274:9 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
-cargo/0.49.0/src/cargo/core/resolver/resolve.rs:280:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/resolver/resolve.rs:284:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/resolver/resolve.rs:288:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/resolver/resolve.rs:292:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/resolver/resolve.rs:296:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/resolver/resolve.rs:300:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/resolver/resolve.rs:315:13 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
-cargo/0.49.0/src/cargo/core/resolver/resolve.rs:354:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/resolver/resolve.rs:362:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/resolver/resolve.rs:60:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/core/resolver/resolve.rs:76:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/resolver/types.rs:111:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/resolver/types.rs:121:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/resolver/types.rs:141:19 clippy::doc_markdown "you should put `ResolveOpts` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/resolver/types.rs:142:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/resolver/types.rs:149:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/resolver/types.rs:181:9 clippy::map_unwrap_or "called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead"
-cargo/0.49.0/src/cargo/core/resolver/types.rs:187:5 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
-cargo/0.49.0/src/cargo/core/resolver/types.rs:261:5 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
-cargo/0.49.0/src/cargo/core/shell.rs:113:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/shell.rs:130:9 clippy::single_match_else "you seem to be trying to use `match` for an equality check. Consider using `if`"
-cargo/0.49.0/src/cargo/core/shell.rs:148:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/shell.rs:153:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/shell.rs:163:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/shell.rs:18:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/shell.rs:198:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/shell.rs:206:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/shell.rs:214:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/shell.rs:228:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/shell.rs:239:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/shell.rs:250:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/shell.rs:259:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/shell.rs:267:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/shell.rs:26:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/shell.rs:277:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/shell.rs:282:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/shell.rs:314:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/shell.rs:322:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/shell.rs:330:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/shell.rs:98:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/source/mod.rs:103:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/source/mod.rs:247:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/core/source/mod.rs:261:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/source/mod.rs:268:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/source/mod.rs:273:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/source/mod.rs:291:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/source/mod.rs:302:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/source/mod.rs:307:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/source/mod.rs:31:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/source/mod.rs:37:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/source/mod.rs:39:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/source/mod.rs:47:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/source/mod.rs:50:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/source/mod.rs:52:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/source/mod.rs:63:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/source/mod.rs:74:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/source/mod.rs:83:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:107:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:128:50 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:147:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:156:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:162:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:166:19 clippy::doc_markdown "you should put `SourceId` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:167:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:171:19 clippy::doc_markdown "you should put `SourceId` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:172:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:178:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:187:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:18:74 clippy::default_trait_access "calling `std::sync::Mutex::default()` is more clear than this expression"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:195:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:207:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:213:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:217:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:225:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:228:16 clippy::option_if_let_else "use Option::map_or_else instead of an if let/else"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:236:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:241:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:252:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:257:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:262:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:305:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:310:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:318:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:326:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:355:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:393:61 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:394:42 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:395:42 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:397:71 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:397:71 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:398:47 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:398:47 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:399:47 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:399:47 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:401:63 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:401:63 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:401:63 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:402:43 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:402:43 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:402:43 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:403:43 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:403:43 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:403:43 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:406:21 clippy::enum_glob_use "usage of wildcard import for enum variants"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:412:41 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:413:36 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:414:36 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:420:47 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:420:47 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:512:17 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:513:17 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:517:17 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:518:17 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:525:17 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:526:17 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:530:17 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:531:17 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:535:33 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:536:37 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:537:42 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:538:38 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:548:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/core/source/source_id.rs:597:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/summary.rs:103:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/summary.rs:123:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/summary.rs:150:1 clippy::too_many_lines "this function has too many lines (141/100)"
-cargo/0.49.0/src/cargo/core/summary.rs:158:9 clippy::enum_glob_use "usage of wildcard import for enum variants"
-cargo/0.49.0/src/cargo/core/summary.rs:181:21 clippy::if_not_else "unnecessary boolean `not` operation"
-cargo/0.49.0/src/cargo/core/summary.rs:192:28 clippy::redundant_else "redundant else block"
-cargo/0.49.0/src/cargo/core/summary.rs:258:32 clippy::redundant_else "redundant else block"
-cargo/0.49.0/src/cargo/core/summary.rs:281:28 clippy::redundant_else "redundant else block"
-cargo/0.49.0/src/cargo/core/summary.rs:303:28 clippy::redundant_else "redundant else block"
-cargo/0.49.0/src/cargo/core/summary.rs:321:51 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/core/summary.rs:344:5 clippy::doc_markdown "you should put `FeatureValue` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/summary.rs:350:85 clippy::doc_markdown "you should put `FeatureValue` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/summary.rs:36:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/summary.rs:378:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/summary.rs:386:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/summary.rs:387:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
-cargo/0.49.0/src/cargo/core/summary.rs:407:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
-cargo/0.49.0/src/cargo/core/summary.rs:69:34 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/summary.rs:75:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/summary.rs:78:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/summary.rs:81:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/summary.rs:84:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/summary.rs:87:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/summary.rs:90:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/summary.rs:93:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/summary.rs:96:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/summary.rs:99:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/workspace.rs:1056:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
-cargo/0.49.0/src/cargo/core/workspace.rs:113:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/core/workspace.rs:1157:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/core/workspace.rs:128:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/core/workspace.rs:150:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/workspace.rs:159:16 clippy::redundant_else "redundant else block"
-cargo/0.49.0/src/cargo/core/workspace.rs:197:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/workspace.rs:225:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/workspace.rs:255:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/workspace.rs:267:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/workspace.rs:329:37 clippy::doc_markdown "you should put `VirtualManifest` between ticks in the documentation"
-cargo/0.49.0/src/cargo/core/workspace.rs:410:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/workspace.rs:440:9 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
-cargo/0.49.0/src/cargo/core/workspace.rs:511:32 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-cargo/0.49.0/src/cargo/core/workspace.rs:561:25 clippy::non_ascii_literal "literal non-ASCII character detected"
-cargo/0.49.0/src/cargo/core/workspace.rs:613:13 clippy::filter_map "called `filter_map(..).map(..)` on an `Iterator`"
-cargo/0.49.0/src/cargo/core/workspace.rs:615:22 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/core/workspace.rs:762:27 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-cargo/0.49.0/src/cargo/core/workspace.rs:784:17 clippy::if_not_else "unnecessary boolean `not` operation"
-cargo/0.49.0/src/cargo/core/workspace.rs:849:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/workspace.rs:893:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/core/workspace.rs:906:24 clippy::redundant_else "redundant else block"
-cargo/0.49.0/src/cargo/core/workspace.rs:932:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/lib.rs:177:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/lib.rs:180:36 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/lib.rs:180:36 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/lib.rs:180:36 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/lib.rs:180:36 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/lib.rs:180:36 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/lib.rs:1:null clippy::cargo_common_metadata "package `cargo` is missing `package.categories` metadata"
-cargo/0.49.0/src/cargo/lib.rs:1:null clippy::cargo_common_metadata "package `cargo` is missing `package.keywords` metadata"
-cargo/0.49.0/src/cargo/lib.rs:1:null clippy::multiple_crate_versions "multiple versions for dependency `crossbeam-utils`: 0.6.6, 0.7.2"
-cargo/0.49.0/src/cargo/lib.rs:1:null clippy::multiple_crate_versions "multiple versions for dependency `hex`: 0.3.2, 0.4.0"
-cargo/0.49.0/src/cargo/lib.rs:1:null clippy::multiple_crate_versions "multiple versions for dependency `humantime`: 1.3.0, 2.0.0"
-cargo/0.49.0/src/cargo/ops/cargo_clean.rs:205:23 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/ops/cargo_clean.rs:27:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/cargo_clean.rs:27:1 clippy::too_many_lines "this function has too many lines (120/100)"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:1078:14 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:109:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:119:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:1227:17 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:127:35 clippy::from_iter_instead_of_collect "usage of `FromIterator::from_iter`"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:173:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:205:36 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:242:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:249:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:258:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:267:16 clippy::needless_question_mark "Question mark operator is useless here"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:275:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:275:1 clippy::too_many_lines "this function has too many lines (219/100)"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:468:9 clippy::default_trait_access "calling `std::collections::HashMap::default()` is more clear than this expression"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:548:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:556:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:574:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:583:21 clippy::doc_markdown "you should put `CompileFilter` between ticks in the documentation"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:584:5 clippy::fn_params_excessive_bools "more than 3 bools in function parameters"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:584:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:592:9 clippy::similar_names "binding's name is too similar to existing binding"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:593:9 clippy::similar_names "binding's name is too similar to existing binding"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:607:13 clippy::similar_names "binding's name is too similar to existing binding"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:612:21 clippy::doc_markdown "you should put `CompileFilter` between ticks in the documentation"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:613:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:618:9 clippy::similar_names "binding's name is too similar to existing binding"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:641:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:652:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:655:50 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:673:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:692:49 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:703:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:729:1 clippy::too_many_lines "this function has too many lines (205/100)"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:82:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/cargo_compile.rs:874:69 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/ops/cargo_doc.rs:20:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/cargo_fetch.rs:15:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/cargo_fetch.rs:27:46 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/ops/cargo_generate_lockfile.rs:160:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/ops/cargo_generate_lockfile.rs:175:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/ops/cargo_generate_lockfile.rs:22:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/cargo_generate_lockfile.rs:37:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/cargo_generate_lockfile.rs:37:1 clippy::too_many_lines "this function has too many lines (171/100)"
-cargo/0.49.0/src/cargo/ops/cargo_install.rs:13:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/cargo/ops/cargo_install.rs:148:1 clippy::fn_params_excessive_bools "more than 3 bools in function parameters"
-cargo/0.49.0/src/cargo/ops/cargo_install.rs:148:1 clippy::too_many_lines "this function has too many lines (316/100)"
-cargo/0.49.0/src/cargo/ops/cargo_install.rs:178:24 clippy::collapsible_else_if "this `else { if .. }` block can be collapsed"
-cargo/0.49.0/src/cargo/ops/cargo_install.rs:202:17 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/ops/cargo_install.rs:236:16 clippy::collapsible_else_if "this `else { if .. }` block can be collapsed"
-cargo/0.49.0/src/cargo/ops/cargo_install.rs:312:64 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/ops/cargo_install.rs:32:13 clippy::let_underscore_drop "non-binding `let` on a type that implements `Drop`"
-cargo/0.49.0/src/cargo/ops/cargo_install.rs:339:12 clippy::collapsible_else_if "this `else { if .. }` block can be collapsed"
-cargo/0.49.0/src/cargo/ops/cargo_install.rs:37:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/cargo_install.rs:454:22 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/ops/cargo_install.rs:483:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/ops/cargo_install.rs:683:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/cargo_new.rs:101:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/cargo_new.rs:245:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/ops/cargo_new.rs:251:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/ops/cargo_new.rs:367:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/cargo_new.rs:405:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/cargo_new.rs:489:5 clippy::doc_markdown "you should put `IgnoreList` between ticks in the documentation"
-cargo/0.49.0/src/cargo/ops/cargo_new.rs:525:47 clippy::doc_markdown "you should put `IgnoreList` between ticks in the documentation"
-cargo/0.49.0/src/cargo/ops/cargo_new.rs:525:9 clippy::doc_markdown "you should put `format_existing` between ticks in the documentation"
-cargo/0.49.0/src/cargo/ops/cargo_new.rs:572:34 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/ops/cargo_new.rs:623:1 clippy::too_many_lines "this function has too many lines (130/100)"
-cargo/0.49.0/src/cargo/ops/cargo_new.rs:781:5 clippy::filter_map_next "called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find_map(..)` instead."
-cargo/0.49.0/src/cargo/ops/cargo_new.rs:800:16 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-cargo/0.49.0/src/cargo/ops/cargo_output_metadata.rs:163:36 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/ops/cargo_output_metadata.rs:27:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/cargo_output_metadata.rs:45:45 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/ops/cargo_package.rs:144:1 clippy::too_many_lines "this function has too many lines (112/100)"
-cargo/0.49.0/src/cargo/ops/cargo_package.rs:207:13 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-cargo/0.49.0/src/cargo/ops/cargo_package.rs:25:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
-cargo/0.49.0/src/cargo/ops/cargo_package.rs:307:54 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/ops/cargo_package.rs:394:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/ops/cargo_package.rs:425:61 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/ops/cargo_package.rs:459:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/ops/cargo_package.rs:66:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/cargo_package.rs:93:20 clippy::if_not_else "unnecessary boolean `not` operation"
-cargo/0.49.0/src/cargo/ops/cargo_pkgid.rs:5:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/cargo_read_manifest.rs:14:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/cargo_read_manifest.rs:171:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/ops/cargo_read_manifest.rs:37:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/cargo_read_manifest.rs:57:49 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/ops/cargo_read_manifest.rs:69:37 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/ops/cargo_run.rs:25:24 clippy::if_not_else "unnecessary boolean `not` operation"
-cargo/0.49.0/src/cargo/ops/cargo_run.rs:35:9 clippy::if_not_else "unnecessary boolean `not` operation"
-cargo/0.49.0/src/cargo/ops/cargo_run.rs:37:16 clippy::redundant_else "redundant else block"
-cargo/0.49.0/src/cargo/ops/cargo_run.rs:53:9 clippy::if_not_else "unnecessary boolean `not` operation"
-cargo/0.49.0/src/cargo/ops/cargo_run.rs:65:16 clippy::redundant_else "redundant else block"
-cargo/0.49.0/src/cargo/ops/cargo_run.rs:9:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/cargo_test.rs:16:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/cargo_test.rs:43:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/cargo_test.rs:84:17 clippy::similar_names "binding's name is too similar to existing binding"
-cargo/0.49.0/src/cargo/ops/cargo_uninstall.rs:14:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/cargo_uninstall.rs:7:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:147:9 clippy::doc_markdown "you should put `PackageId` between ticks in the documentation"
-cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:233:21 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
-cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:244:22 clippy::doc_markdown "you should put `PackageId` between ticks in the documentation"
-cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:244:63 clippy::doc_markdown "you should put `PackageId` between ticks in the documentation"
-cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:253:17 clippy::if_not_else "unnecessary boolean `not` operation"
-cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:370:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
-cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:505:8 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
-cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:525:10 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
-cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:542:27 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:542:5 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:561:20 clippy::redundant_else "redundant else block"
-cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:613:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:645:41 clippy::doc_markdown "you should put `BTreeSet` between ticks in the documentation"
-cargo/0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:92:19 clippy::doc_markdown "you should put `InstallTracker` between ticks in the documentation"
-cargo/0.49.0/src/cargo/ops/fix.rs:200:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/fix.rs:200:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/ops/fix.rs:424:20 clippy::map_unwrap_or "called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead"
-cargo/0.49.0/src/cargo/ops/fix.rs:455:13 clippy::similar_names "binding's name is too similar to existing binding"
-cargo/0.49.0/src/cargo/ops/fix.rs:506:17 clippy::similar_names "binding's name is too similar to existing binding"
-cargo/0.49.0/src/cargo/ops/fix.rs:608:9 clippy::field_reassign_with_default "field assignment outside of initializer for an instance created with Default::default()"
-cargo/0.49.0/src/cargo/ops/fix.rs:612:42 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/ops/fix.rs:619:48 clippy::manual_strip "stripping a prefix manually"
-cargo/0.49.0/src/cargo/ops/fix.rs:66:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/ops/fix.rs:66:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
-cargo/0.49.0/src/cargo/ops/fix.rs:708:18 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/ops/fix.rs:77:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/lockfile.rs:154:13 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
-cargo/0.49.0/src/cargo/ops/lockfile.rs:217:9 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
-cargo/0.49.0/src/cargo/ops/lockfile.rs:30:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/lockfile.rs:35:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/lockfile.rs:35:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-cargo/0.49.0/src/cargo/ops/lockfile.rs:87:1 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
-cargo/0.49.0/src/cargo/ops/lockfile.rs:8:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/lockfile.rs:8:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-cargo/0.49.0/src/cargo/ops/registry.rs:150:21 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/ops/registry.rs:188:1 clippy::too_many_lines "this function has too many lines (130/100)"
-cargo/0.49.0/src/cargo/ops/registry.rs:212:32 clippy::if_not_else "unnecessary `!=` operation"
-cargo/0.49.0/src/cargo/ops/registry.rs:222:53 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/ops/registry.rs:224:44 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/ops/registry.rs:31:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/ops/registry.rs:346:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/registry.rs:346:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/ops/registry.rs:351:26 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-cargo/0.49.0/src/cargo/ops/registry.rs:385:12 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
-cargo/0.49.0/src/cargo/ops/registry.rs:386:15 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
-cargo/0.49.0/src/cargo/ops/registry.rs:38:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
-cargo/0.49.0/src/cargo/ops/registry.rs:477:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/registry.rs:483:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/registry.rs:503:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/registry.rs:505:38 clippy::default_trait_access "calling `util::config::CargoHttpConfig::default()` is more clear than this expression"
-cargo/0.49.0/src/cargo/ops/registry.rs:510:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/registry.rs:529:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/ops/registry.rs:53:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/registry.rs:573:22 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/ops/registry.rs:608:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/registry.rs:621:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/registry.rs:671:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/registry.rs:671:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/ops/registry.rs:674:10 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
-cargo/0.49.0/src/cargo/ops/registry.rs:678:17 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-cargo/0.49.0/src/cargo/ops/registry.rs:730:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/registry.rs:731:16 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-cargo/0.49.0/src/cargo/ops/registry.rs:785:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/registry.rs:794:16 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-cargo/0.49.0/src/cargo/ops/registry.rs:828:14 clippy::doc_markdown "you should put `SourceId` between ticks in the documentation"
-cargo/0.49.0/src/cargo/ops/registry.rs:848:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/resolve.rs:199:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/resolve.rs:199:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/ops/resolve.rs:199:1 clippy::too_many_lines "this function has too many lines (137/100)"
-cargo/0.49.0/src/cargo/ops/resolve.rs:241:28 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-cargo/0.49.0/src/cargo/ops/resolve.rs:28:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-cargo/0.49.0/src/cargo/ops/resolve.rs:384:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/resolve.rs:417:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/resolve.rs:589:9 clippy::shadow_unrelated "`keep` is being shadowed"
-cargo/0.49.0/src/cargo/ops/resolve.rs:58:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/resolve.rs:58:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/ops/resolve.rs:602:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/ops/resolve.rs:75:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/resolve.rs:75:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/ops/tree/graph.rs:129:26 clippy::doc_markdown "you should put `PackageIds` between ticks in the documentation"
-cargo/0.49.0/src/cargo/ops/tree/graph.rs:152:15 clippy::match_on_vec_items "indexing into a vector may panic"
-cargo/0.49.0/src/cargo/ops/tree/graph.rs:173:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/ops/tree/graph.rs:234:46 clippy::filter_map "called `filter(..).flat_map(..)` on an `Iterator`"
-cargo/0.49.0/src/cargo/ops/tree/graph.rs:328:44 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/ops/tree/graph.rs:330:50 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/ops/tree/graph.rs:563:35 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-cargo/0.49.0/src/cargo/ops/tree/mod.rs:112:11 clippy::non_ascii_literal "literal non-ASCII character detected"
-cargo/0.49.0/src/cargo/ops/tree/mod.rs:113:10 clippy::non_ascii_literal "literal non-ASCII character detected"
-cargo/0.49.0/src/cargo/ops/tree/mod.rs:114:10 clippy::non_ascii_literal "literal non-ASCII character detected"
-cargo/0.49.0/src/cargo/ops/tree/mod.rs:115:12 clippy::non_ascii_literal "literal non-ASCII character detected"
-cargo/0.49.0/src/cargo/ops/tree/mod.rs:126:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/tree/mod.rs:21:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/ops/tree/mod.rs:21:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
-cargo/0.49.0/src/cargo/ops/tree/mod.rs:360:30 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/ops/tree/mod.rs:58:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/ops/vendor.rs:14:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/ops/vendor.rs:21:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/ops/vendor.rs:314:34 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/ops/vendor.rs:320:29 clippy::case_sensitive_file_extension_comparisons "case-sensitive file extension comparison"
-cargo/0.49.0/src/cargo/ops/vendor.rs:320:60 clippy::case_sensitive_file_extension_comparisons "case-sensitive file extension comparison"
-cargo/0.49.0/src/cargo/ops/vendor.rs:324:13 clippy::match_wildcard_for_single_variants "wildcard match will miss any future added variants"
-cargo/0.49.0/src/cargo/ops/vendor.rs:70:1 clippy::too_many_lines "this function has too many lines (175/100)"
-cargo/0.49.0/src/cargo/sources/config.rs:102:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/sources/config.rs:111:28 clippy::needless_question_mark "Question mark operator is useless here"
-cargo/0.49.0/src/cargo/sources/config.rs:133:48 clippy::needless_question_mark "Question mark operator is useless here"
-cargo/0.49.0/src/cargo/sources/config.rs:135:67 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/sources/config.rs:206:36 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
-cargo/0.49.0/src/cargo/sources/config.rs:282:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/sources/config.rs:70:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/sources/config.rs:81:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/sources/config.rs:97:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/sources/directory.rs:14:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/sources/directory.rs:90:56 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/sources/git/source.rs:14:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-cargo/0.49.0/src/cargo/sources/git/source.rs:25:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/sources/git/source.rs:49:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/sources/git/source.rs:53:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/sources/git/source.rs:69:20 clippy::comparison_to_empty "comparison to empty slice"
-cargo/0.49.0/src/cargo/sources/git/utils.rs:1025:19 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-cargo/0.49.0/src/cargo/sources/git/utils.rs:1157:36 clippy::case_sensitive_file_extension_comparisons "case-sensitive file extension comparison"
-cargo/0.49.0/src/cargo/sources/git/utils.rs:1158:9 clippy::manual_strip "stripping a suffix manually"
-cargo/0.49.0/src/cargo/sources/git/utils.rs:134:12 clippy::upper_case_acronyms "name `GitShortID` contains a capitalized acronym"
-cargo/0.49.0/src/cargo/sources/git/utils.rs:176:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/sources/git/utils.rs:180:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/sources/git/utils.rs:184:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/sources/git/utils.rs:188:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/sources/git/utils.rs:242:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/sources/git/utils.rs:253:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/sources/git/utils.rs:262:13 clippy::if_not_else "unnecessary boolean `not` operation"
-cargo/0.49.0/src/cargo/sources/git/utils.rs:289:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/sources/git/utils.rs:294:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/sources/git/utils.rs:298:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/sources/git/utils.rs:308:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/sources/git/utils.rs:472:9 clippy::let_underscore_drop "non-binding `let` on a type that implements `Drop`"
-cargo/0.49.0/src/cargo/sources/git/utils.rs:489:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/sources/git/utils.rs:503:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/sources/git/utils.rs:528:28 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-cargo/0.49.0/src/cargo/sources/git/utils.rs:537:21 clippy::let_underscore_drop "non-binding `let` on a type that implements `Drop`"
-cargo/0.49.0/src/cargo/sources/git/utils.rs:588:1 clippy::too_many_lines "this function has too many lines (135/100)"
-cargo/0.49.0/src/cargo/sources/git/utils.rs:692:9 clippy::vec_init_then_push "calls to `push` immediately after creation"
-cargo/0.49.0/src/cargo/sources/git/utils.rs:758:9 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
-cargo/0.49.0/src/cargo/sources/git/utils.rs:858:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/sources/path.rs:129:44 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/sources/path.rs:143:44 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/sources/path.rs:15:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/sources/path.rs:282:50 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/sources/path.rs:313:21 clippy::similar_names "binding's name is too similar to existing binding"
-cargo/0.49.0/src/cargo/sources/path.rs:314:21 clippy::similar_names "binding's name is too similar to existing binding"
-cargo/0.49.0/src/cargo/sources/path.rs:319:21 clippy::similar_names "binding's name is too similar to existing binding"
-cargo/0.49.0/src/cargo/sources/path.rs:339:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/sources/path.rs:339:9 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
-cargo/0.49.0/src/cargo/sources/path.rs:380:9 clippy::unused_self "unused `self` argument"
-cargo/0.49.0/src/cargo/sources/path.rs:419:50 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/sources/path.rs:429:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/sources/path.rs:460:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/sources/path.rs:473:43 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/sources/path.rs:482:43 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/sources/path.rs:63:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/sources/path.rs:77:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/sources/path.rs:98:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/sources/registry/index.rs:117:23 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-cargo/0.49.0/src/cargo/sources/registry/index.rs:121:70 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-cargo/0.49.0/src/cargo/sources/registry/index.rs:167:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-cargo/0.49.0/src/cargo/sources/registry/index.rs:215:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/sources/registry/index.rs:324:23 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/sources/registry/index.rs:468:40 clippy::doc_markdown "you should put `SourceId` between ticks in the documentation"
-cargo/0.49.0/src/cargo/sources/registry/index.rs:590:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/sources/registry/index.rs:648:17 clippy::similar_names "binding's name is too similar to existing binding"
-cargo/0.49.0/src/cargo/sources/registry/index.rs:736:1 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
-cargo/0.49.0/src/cargo/sources/registry/index.rs:95:37 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
-cargo/0.49.0/src/cargo/sources/registry/local.rs:12:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/sources/registry/mod.rs:192:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/sources/registry/mod.rs:203:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/sources/registry/mod.rs:229:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/sources/registry/mod.rs:372:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/sources/registry/mod.rs:373:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/sources/registry/mod.rs:375:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/sources/registry/mod.rs:381:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/sources/registry/mod.rs:382:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/sources/registry/mod.rs:383:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/sources/registry/mod.rs:384:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/sources/registry/mod.rs:452:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/sources/registry/mod.rs:582:20 clippy::redundant_else "redundant else block"
-cargo/0.49.0/src/cargo/sources/registry/mod.rs:621:9 clippy::if_not_else "unnecessary `!=` operation"
-cargo/0.49.0/src/cargo/sources/registry/remote.rs:139:17 clippy::unused_self "unused `self` argument"
-cargo/0.49.0/src/cargo/sources/registry/remote.rs:32:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/sources/registry/remote.rs:72:13 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-cargo/0.49.0/src/cargo/sources/replaced.rs:12:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/sources/replaced.rs:5:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/util/canonical_url.rs:19:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/canonical_url.rs:50:41 clippy::case_sensitive_file_extension_comparisons "case-sensitive file extension comparison"
-cargo/0.49.0/src/cargo/util/canonical_url.rs:65:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/command_prelude.rs:218:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/command_prelude.rs:222:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/command_prelude.rs:234:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/command_prelude.rs:249:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/command_prelude.rs:264:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/command_prelude.rs:279:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/command_prelude.rs:298:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/command_prelude.rs:320:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/command_prelude.rs:328:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/command_prelude.rs:352:13 clippy::if_not_else "unnecessary boolean `not` operation"
-cargo/0.49.0/src/cargo/util/command_prelude.rs:363:13 clippy::if_not_else "unnecessary boolean `not` operation"
-cargo/0.49.0/src/cargo/util/command_prelude.rs:378:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/command_prelude.rs:387:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/command_prelude.rs:387:5 clippy::too_many_lines "this function has too many lines (104/100)"
-cargo/0.49.0/src/cargo/util/command_prelude.rs:39:20 clippy::doc_markdown "you should put `arg_package_spec` between ticks in the documentation"
-cargo/0.49.0/src/cargo/util/command_prelude.rs:504:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/command_prelude.rs:516:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/command_prelude.rs:530:40 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/util/command_prelude.rs:531:43 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/util/command_prelude.rs:536:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/command_prelude.rs:556:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/command_prelude.rs:575:49 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/util/command_prelude.rs:580:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/command_prelude.rs:631:18 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/util/command_prelude.rs:638:18 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/util/command_prelude.rs:647:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/command_prelude.rs:651:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/command_prelude.rs:662:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/command_prelude.rs:665:51 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/util/config/de.rs:420:16 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
-cargo/0.49.0/src/cargo/util/config/de.rs:46:25 clippy::doc_markdown "you should put `CV::List` between ticks in the documentation"
-cargo/0.49.0/src/cargo/util/config/de.rs:47:24 clippy::doc_markdown "you should put `ConfigSeqAccess` between ticks in the documentation"
-cargo/0.49.0/src/cargo/util/config/de.rs:527:53 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-cargo/0.49.0/src/cargo/util/config/de.rs:530:53 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-cargo/0.49.0/src/cargo/util/config/de.rs:532:68 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-cargo/0.49.0/src/cargo/util/config/key.rs:11:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-cargo/0.49.0/src/cargo/util/config/key.rs:69:9 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
-cargo/0.49.0/src/cargo/util/config/mod.rs:100:71 clippy::doc_markdown "you should put `OptValue` between ticks in the documentation"
-cargo/0.49.0/src/cargo/util/config/mod.rs:100:71 clippy::doc_markdown "you should put `OptValue` between ticks in the documentation"
-cargo/0.49.0/src/cargo/util/config/mod.rs:100:71 clippy::doc_markdown "you should put `OptValue` between ticks in the documentation"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1049:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1064:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1090:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1166:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1179:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1181:33 clippy::needless_question_mark "Question mark operator is useless here"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1184:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1186:33 clippy::needless_question_mark "Question mark operator is useless here"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1189:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1191:33 clippy::needless_question_mark "Question mark operator is useless here"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1203:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1211:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1216:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1225:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1229:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:124:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1254:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1279:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1281:9 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1323:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1339:39 clippy::unused_self "unused `self` argument"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1344:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1420:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1553:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1560:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1567:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1574:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1581:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1588:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1598:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1619:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1623:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1623:64 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1649:9 clippy::option_if_let_else "use Option::map_or_else instead of an if let/else"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1699:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1730:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1757:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1770:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1778:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1804:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1896:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/config/mod.rs:1901:5 clippy::doc_markdown "you should put `StringList` between ticks in the documentation"
-cargo/0.49.0/src/cargo/util/config/mod.rs:214:13 clippy::match_wildcard_for_single_variants "wildcard match will miss any future added variants"
-cargo/0.49.0/src/cargo/util/config/mod.rs:259:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:298:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:311:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:318:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:353:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:401:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:411:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:419:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:431:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:449:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:454:16 clippy::option_if_let_else "use Option::map_or instead of an if let/else"
-cargo/0.49.0/src/cargo/util/config/mod.rs:547:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:556:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:582:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:595:20 clippy::doc_markdown "you should put `StringList` between ticks in the documentation"
-cargo/0.49.0/src/cargo/util/config/mod.rs:689:20 clippy::unused_self "unused `self` argument"
-cargo/0.49.0/src/cargo/util/config/mod.rs:699:5 clippy::fn_params_excessive_bools "more than 3 bools in function parameters"
-cargo/0.49.0/src/cargo/util/config/mod.rs:699:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:719:58 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/util/config/mod.rs:816:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/config/mod.rs:875:36 clippy::similar_names "binding's name is too similar to existing binding"
-cargo/0.49.0/src/cargo/util/config/mod.rs:876:37 clippy::similar_names "binding's name is too similar to existing binding"
-cargo/0.49.0/src/cargo/util/config/path.rs:10:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-cargo/0.49.0/src/cargo/util/config/path.rs:14:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/config/path.rs:48:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/util/config/target.rs:12:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/util/config/target.rs:24:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/util/config/value.rs:29:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-cargo/0.49.0/src/cargo/util/config/value.rs:80:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/config/value.rs:81:9 clippy::match_like_matches_macro "match expression looks like `matches!` macro"
-cargo/0.49.0/src/cargo/util/cpu.rs:11:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/cpu.rs:22:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/cpu.rs:82:25 clippy::cast_precision_loss "casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
-cargo/0.49.0/src/cargo/util/cpu.rs:82:9 clippy::cast_precision_loss "casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
-cargo/0.49.0/src/cargo/util/dependency_queue.rs:109:27 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/util/dependency_queue.rs:151:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/dependency_queue.rs:156:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/dependency_queue.rs:46:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/dependency_queue.rs:91:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/util/diagnostic_server.rs:218:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-cargo/0.49.0/src/cargo/util/diagnostic_server.rs:230:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/diagnostic_server.rs:242:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/diagnostic_server.rs:58:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/diagnostic_server.rs:96:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/diagnostic_server.rs:96:5 clippy::too_many_lines "this function has too many lines (110/100)"
-cargo/0.49.0/src/cargo/util/diagnostic_server.rs:99:21 clippy::shadow_unrelated "`msg` is being shadowed"
-cargo/0.49.0/src/cargo/util/errors.rs:101:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/errors.rs:143:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/errors.rs:150:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/errors.rs:15:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/errors.rs:237:5 clippy::pub_enum_variant_names "variant name ends with the enum's name"
-cargo/0.49.0/src/cargo/util/errors.rs:245:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/errors.rs:321:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/errors.rs:328:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/errors.rs:356:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/errors.rs:391:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/util/errors.rs:392:13 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/cargo/util/errors.rs:465:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/errors.rs:473:5 clippy::manual_range_contains "manual `RangeInclusive::contains` implementation"
-cargo/0.49.0/src/cargo/util/errors.rs:66:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/flock.rs:115:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/flock.rs:11:5 clippy::wildcard_imports "usage of wildcard import"
-cargo/0.49.0/src/cargo/util/flock.rs:134:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/flock.rs:142:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/flock.rs:150:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/flock.rs:156:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/flock.rs:170:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/flock.rs:192:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/flock.rs:29:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/flock.rs:321:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/util/flock.rs:335:23 clippy::cast_possible_truncation "casting `i64` to `u32` may truncate the value"
-cargo/0.49.0/src/cargo/util/flock.rs:335:23 clippy::cast_sign_loss "casting `i64` to `u32` may lose the sign of the value"
-cargo/0.49.0/src/cargo/util/flock.rs:335:44 clippy::cast_possible_truncation "casting `i64` to `u32` may truncate the value"
-cargo/0.49.0/src/cargo/util/flock.rs:379:35 clippy::match_same_arms "this `match` has identical arm bodies"
-cargo/0.49.0/src/cargo/util/flock.rs:37:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/flock.rs:43:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/flock.rs:52:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/graph.rs:10:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/graph.rs:41:51 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/util/graph.rs:45:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/hasher.rs:12:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/hasher.rs:9:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-cargo/0.49.0/src/cargo/util/hex.rs:10:9 clippy::cast_possible_truncation "casting `u64` to `u8` may truncate the value"
-cargo/0.49.0/src/cargo/util/hex.rs:11:9 clippy::cast_possible_truncation "casting `u64` to `u8` may truncate the value"
-cargo/0.49.0/src/cargo/util/hex.rs:12:9 clippy::cast_possible_truncation "casting `u64` to `u8` may truncate the value"
-cargo/0.49.0/src/cargo/util/hex.rs:13:9 clippy::cast_possible_truncation "casting `u64` to `u8` may truncate the value"
-cargo/0.49.0/src/cargo/util/hex.rs:14:9 clippy::cast_possible_truncation "casting `u64` to `u8` may truncate the value"
-cargo/0.49.0/src/cargo/util/hex.rs:15:9 clippy::cast_possible_truncation "casting `u64` to `u8` may truncate the value"
-cargo/0.49.0/src/cargo/util/hex.rs:25:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/hex.rs:6:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-cargo/0.49.0/src/cargo/util/hex.rs:6:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/hex.rs:8:9 clippy::cast_possible_truncation "casting `u64` to `u8` may truncate the value"
-cargo/0.49.0/src/cargo/util/hex.rs:9:9 clippy::cast_possible_truncation "casting `u64` to `u8` may truncate the value"
-cargo/0.49.0/src/cargo/util/important_paths.rs:23:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/important_paths.rs:6:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/interning.rs:66:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/interning.rs:77:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/into_url.rs:10:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/into_url_with_base.rs:9:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/job.rs:20:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/lev_distance.rs:3:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/lockserver.rs:111:32 clippy::redundant_else "redundant else block"
-cargo/0.49.0/src/cargo/util/lockserver.rs:158:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/lockserver.rs:46:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/lockserver.rs:58:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/lockserver.rs:62:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/mod.rs:68:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/mod.rs:79:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/network.rs:12:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/network.rs:19:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/network.rs:84:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/paths.rs:109:12 clippy::redundant_else "redundant else block"
-cargo/0.49.0/src/cargo/util/paths.rs:114:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/paths.rs:121:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/paths.rs:125:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/paths.rs:130:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/paths.rs:14:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/paths.rs:14:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-cargo/0.49.0/src/cargo/util/paths.rs:151:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/paths.rs:167:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/paths.rs:173:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/paths.rs:178:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/paths.rs:185:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/paths.rs:199:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/paths.rs:215:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/paths.rs:228:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/paths.rs:251:9 clippy::option_if_let_else "use Option::map_or instead of an if let/else"
-cargo/0.49.0/src/cargo/util/paths.rs:267:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/paths.rs:276:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/paths.rs:29:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/paths.rs:303:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/paths.rs:312:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/paths.rs:346:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/paths.rs:415:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/paths.rs:445:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/paths.rs:459:45 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/util/paths.rs:469:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/paths.rs:54:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/paths.rs:61:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/paths.rs:63:19 clippy::option_if_let_else "use Option::map_or_else instead of an if let/else"
-cargo/0.49.0/src/cargo/util/paths.rs:88:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/paths.rs:93:31 clippy::comparison_to_empty "comparison to empty slice"
-cargo/0.49.0/src/cargo/util/process_builder.rs:106:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/process_builder.rs:111:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/process_builder.rs:122:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/process_builder.rs:132:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/process_builder.rs:152:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/process_builder.rs:185:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/process_builder.rs:190:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/process_builder.rs:218:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/process_builder.rs:307:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/process_builder.rs:343:39 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
-cargo/0.49.0/src/cargo/util/progress.rs:122:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/progress.rs:136:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/progress.rs:15:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/util/progress.rs:249:19 clippy::cast_precision_loss "casting `usize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`usize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
-cargo/0.49.0/src/cargo/util/progress.rs:249:34 clippy::cast_precision_loss "casting `usize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`usize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
-cargo/0.49.0/src/cargo/util/progress.rs:250:19 clippy::if_not_else "unnecessary boolean `not` operation"
-cargo/0.49.0/src/cargo/util/progress.rs:263:22 clippy::cast_precision_loss "casting `usize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`usize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
-cargo/0.49.0/src/cargo/util/progress.rs:264:22 clippy::cast_possible_truncation "casting `f64` to `usize` may truncate the value"
-cargo/0.49.0/src/cargo/util/progress.rs:264:22 clippy::cast_sign_loss "casting `f64` to `usize` may lose the sign of the value"
-cargo/0.49.0/src/cargo/util/progress.rs:269:17 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
-cargo/0.49.0/src/cargo/util/progress.rs:272:17 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
-cargo/0.49.0/src/cargo/util/progress.rs:274:17 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
-cargo/0.49.0/src/cargo/util/progress.rs:280:13 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
-cargo/0.49.0/src/cargo/util/progress.rs:282:9 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
-cargo/0.49.0/src/cargo/util/progress.rs:89:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/progress.rs:97:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/queue.rs:25:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/read2.rs:11:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/read2.rs:31:17 clippy::similar_names "binding's name is too similar to existing binding"
-cargo/0.49.0/src/cargo/util/restricted_names.rs:13:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/restricted_names.rs:26:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/restricted_names.rs:35:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/restricted_names.rs:45:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/restricted_names.rs:87:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/restricted_names.rs:89:21 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/util/restricted_names.rs:8:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/rustc.rs:103:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/rustc.rs:114:5 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
-cargo/0.49.0/src/cargo/util/rustc.rs:115:5 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
-cargo/0.49.0/src/cargo/util/rustc.rs:162:17 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/util/rustc.rs:39:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/sha256.rs:10:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/sha256.rs:20:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/sha256.rs:31:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/sha256.rs:40:24 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-cargo/0.49.0/src/cargo/util/to_semver.rs:5:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:1005:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:1005:5 clippy::too_many_lines "this function has too many lines (282/100)"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:1094:36 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:1121:13 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:1197:32 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:124:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:1504:9 clippy::unused_self "unused `self` argument"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:1526:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:1582:19 clippy::default_trait_access "calling `util::toml::DetailedTomlDependency::default()` is more clear than this expression"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:1598:5 clippy::too_many_lines "this function has too many lines (153/100)"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:1687:33 clippy::unnecessary_lazy_evaluations "unnecessary closure used to substitute value for `Option::None`"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:178:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:248:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:274:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:277:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:281:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:285:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:294:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:31:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:381:35 clippy::cast_possible_truncation "casting `i64` to `u32` may truncate the value"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:381:35 clippy::cast_sign_loss "casting `i64` to `u32` may lose the sign of the value"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:388:35 clippy::cast_possible_truncation "casting `u64` to `u32` may truncate the value"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:398:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:450:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:536:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:783:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:824:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:834:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:83:42 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:852:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:852:5 clippy::too_many_lines "this function has too many lines (138/100)"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:962:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:979:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:98:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/util/toml/mod.rs:999:23 clippy::default_trait_access "calling `util::toml::DetailedTomlDependency::default()` is more clear than this expression"
-cargo/0.49.0/src/cargo/util/toml/targets.rs:112:27 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/util/toml/targets.rs:325:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-cargo/0.49.0/src/cargo/util/toml/targets.rs:586:21 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/util/toml/targets.rs:593:42 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/util/toml/targets.rs:605:19 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/util/toml/targets.rs:612:42 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/util/toml/targets.rs:756:36 clippy::redundant_closure_for_method_calls "redundant closure found"
-cargo/0.49.0/src/cargo/util/vcs.rs:10:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-cargo/0.49.0/src/cargo/util/vcs.rs:33:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/vcs.rs:37:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/vcs.rs:43:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/vcs.rs:47:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/vcs.rs:59:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/vcs.rs:66:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/workspace.rs:52:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/workspace.rs:56:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/workspace.rs:60:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-cargo/0.49.0/src/cargo/util/workspace.rs:64:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-iron/0.6.1/src/error.rs:24:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-iron/0.6.1/src/iron.rs:105:13 clippy::redundant_field_names "redundant field names in struct initialization"
-iron/0.6.1/src/iron.rs:119:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-iron/0.6.1/src/iron.rs:133:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-iron/0.6.1/src/iron.rs:143:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-iron/0.6.1/src/iron.rs:149:13 clippy::redundant_field_names "redundant field names in struct initialization"
-iron/0.6.1/src/iron.rs:167:49 clippy::similar_names "binding's name is too similar to existing binding"
-iron/0.6.1/src/iron.rs:80:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-iron/0.6.1/src/iron.rs:85:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-iron/0.6.1/src/iron.rs:90:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-iron/0.6.1/src/lib.rs:1:null clippy::cargo_common_metadata "package `iron` is missing `package.categories` metadata"
-iron/0.6.1/src/lib.rs:1:null clippy::cargo_common_metadata "package `iron` is missing `package.keywords` metadata"
-iron/0.6.1/src/lib.rs:1:null clippy::multiple_crate_versions "multiple versions for dependency `log`: 0.3.9, 0.4.8"
-iron/0.6.1/src/middleware/mod.rs:137:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-iron/0.6.1/src/middleware/mod.rs:150:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-iron/0.6.1/src/middleware/mod.rs:152:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-iron/0.6.1/src/middleware/mod.rs:159:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-iron/0.6.1/src/middleware/mod.rs:171:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-iron/0.6.1/src/middleware/mod.rs:173:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-iron/0.6.1/src/middleware/mod.rs:182:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-iron/0.6.1/src/middleware/mod.rs:192:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-iron/0.6.1/src/middleware/mod.rs:217:25 clippy::doc_markdown "you should put `ChainBuilder` between ticks in the documentation"
-iron/0.6.1/src/middleware/mod.rs:328:20 clippy::similar_names "binding's name is too similar to existing binding"
-iron/0.6.1/src/middleware/mod.rs:360:16 clippy::similar_names "binding's name is too similar to existing binding"
-iron/0.6.1/src/middleware/mod.rs:368:33 clippy::similar_names "binding's name is too similar to existing binding"
-iron/0.6.1/src/middleware/mod.rs:428:40 clippy::similar_names "binding's name is too similar to existing binding"
-iron/0.6.1/src/middleware/mod.rs:434:40 clippy::similar_names "binding's name is too similar to existing binding"
-iron/0.6.1/src/middleware/mod.rs:444:40 clippy::similar_names "binding's name is too similar to existing binding"
-iron/0.6.1/src/modifiers.rs:132:14 clippy::expect_fun_call "use of `expect` followed by a function call"
-iron/0.6.1/src/request/mod.rs:113:24 clippy::similar_names "binding's name is too similar to existing binding"
-iron/0.6.1/src/request/mod.rs:121:13 clippy::redundant_field_names "redundant field names in struct initialization"
-iron/0.6.1/src/request/mod.rs:123:13 clippy::redundant_field_names "redundant field names in struct initialization"
-iron/0.6.1/src/request/mod.rs:124:13 clippy::redundant_field_names "redundant field names in struct initialization"
-iron/0.6.1/src/request/mod.rs:126:13 clippy::redundant_field_names "redundant field names in struct initialization"
-iron/0.6.1/src/request/mod.rs:128:13 clippy::redundant_field_names "redundant field names in struct initialization"
-iron/0.6.1/src/request/mod.rs:153:69 clippy::doc_markdown "you should put `HttpReader` between ticks in the documentation"
-iron/0.6.1/src/request/mod.rs:154:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-iron/0.6.1/src/request/mod.rs:32:1 clippy::manual_non_exhaustive "this seems like a manual implementation of the non-exhaustive pattern"
-iron/0.6.1/src/request/mod.rs:75:34 clippy::doc_markdown "you should put `HttpRequest` between ticks in the documentation"
-iron/0.6.1/src/request/mod.rs:77:39 clippy::doc_markdown "you should put `HttpRequest` between ticks in the documentation"
-iron/0.6.1/src/request/mod.rs:78:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-iron/0.6.1/src/request/mod.rs:82:13 clippy::similar_names "binding's name is too similar to existing binding"
-iron/0.6.1/src/request/mod.rs:83:29 clippy::similar_names "binding's name is too similar to existing binding"
-iron/0.6.1/src/request/mod.rs:85:24 clippy::similar_names "binding's name is too similar to existing binding"
-iron/0.6.1/src/request/url.rs:109:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-iron/0.6.1/src/request/url.rs:117:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-iron/0.6.1/src/request/url.rs:129:1 clippy::from_over_into "an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true"
-iron/0.6.1/src/request/url.rs:21:14 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
-iron/0.6.1/src/request/url.rs:22:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-iron/0.6.1/src/request/url.rs:31:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-iron/0.6.1/src/request/url.rs:47:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-iron/0.6.1/src/request/url.rs:52:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-iron/0.6.1/src/request/url.rs:57:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-iron/0.6.1/src/request/url.rs:63:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-iron/0.6.1/src/request/url.rs:73:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-iron/0.6.1/src/request/url.rs:83:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-iron/0.6.1/src/request/url.rs:96:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-iron/0.6.1/src/response.rs:121:19 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-iron/0.6.1/src/response.rs:125:43 clippy::redundant_closure_for_method_calls "redundant closure found"
-iron/0.6.1/src/response.rs:139:41 clippy::redundant_closure_for_method_calls "redundant closure found"
-iron/0.6.1/src/response.rs:24:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-iron/0.6.1/src/response.rs:95:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-iron/0.6.1/src/response.rs:95:5 clippy::new_without_default "you should consider adding a `Default` implementation for `response::Response`"
-libc/0.2.81/build.rs:114:19 clippy::map_unwrap_or "called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead"
-libc/0.2.81/build.rs:124:5 clippy::question_mark "this block may be rewritten with the `?` operator"
-libc/0.2.81/build.rs:133:5 clippy::question_mark "this block may be rewritten with the `?` operator"
-libc/0.2.81/src/macros.rs:243:17 clippy::missing_safety_doc "unsafe function's docs miss `# Safety` section"
-libc/0.2.81/src/macros.rs:243:17 clippy::missing_safety_doc "unsafe function's docs miss `# Safety` section"
-libc/0.2.81/src/macros.rs:243:17 clippy::missing_safety_doc "unsafe function's docs miss `# Safety` section"
-libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:428:29 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:429:30 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:431:30 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:432:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:433:29 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:434:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:595:33 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:596:33 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:597:35 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:622:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:673:34 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:696:33 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:697:35 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:698:33 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:699:35 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:712:34 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:721:35 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:722:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:723:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:751:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:752:30 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:753:30 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:754:30 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:755:29 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:756:29 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:757:29 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:758:29 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:759:29 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:760:29 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:768:30 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:769:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:771:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:772:29 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:773:29 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:774:29 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:775:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:776:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:777:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:778:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:779:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:780:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:781:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:782:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:783:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:784:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:785:33 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:786:33 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:787:30 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:788:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:789:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:790:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:791:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:792:33 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:794:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:795:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:796:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:797:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:798:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:799:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:800:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:801:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:803:27 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:804:28 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:805:28 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:806:29 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:807:29 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:808:29 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:809:29 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:810:29 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:811:29 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:812:30 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:813:30 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:814:30 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:815:30 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:816:30 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:817:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:818:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:821:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:822:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:823:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:824:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:825:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:826:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:827:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:828:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:829:33 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:830:33 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:831:33 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:832:33 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:833:33 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:834:33 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:835:33 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:836:33 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:841:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:842:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:843:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:844:33 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:1120:38 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:178:34 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:291:5 clippy::missing_safety_doc "unsafe function's docs miss `# Safety` section"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:291:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:299:11 clippy::ptr_as_ptr "`as` casting between raw pointers without changing its mutability"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:302:5 clippy::missing_safety_doc "unsafe function's docs miss `# Safety` section"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:302:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:312:11 clippy::ptr_as_ptr "`as` casting between raw pointers without changing its mutability"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:352:20 clippy::ptr_as_ptr "`as` casting between raw pointers without changing its mutability"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:355:13 clippy::missing_safety_doc "unsafe function's docs miss `# Safety` section"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:355:13 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:359:13 clippy::missing_safety_doc "unsafe function's docs miss `# Safety` section"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:359:13 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:363:13 clippy::missing_safety_doc "unsafe function's docs miss `# Safety` section"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:363:13 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:367:13 clippy::missing_safety_doc "unsafe function's docs miss `# Safety` section"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:367:13 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:371:13 clippy::missing_safety_doc "unsafe function's docs miss `# Safety` section"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:371:13 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:534:36 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:645:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:727:40 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:728:40 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:729:39 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:731:44 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:732:36 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:733:41 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:734:43 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:735:42 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:736:40 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:737:36 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:738:37 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:741:39 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:742:40 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:743:40 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:744:40 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:745:40 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:746:43 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:747:42 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:748:40 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:749:39 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:750:41 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:751:41 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:752:43 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:753:42 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:755:42 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:756:41 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:757:41 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:758:39 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:759:39 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:761:41 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:762:44 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:763:45 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:764:40 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:765:40 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:766:40 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:767:44 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:768:44 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:769:39 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:770:35 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:771:35 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:772:37 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:773:39 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:774:45 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:775:41 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:776:39 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:803:34 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:841:30 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:842:37 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:982:40 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/gnu/mod.rs:984:46 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1209:36 clippy::cast_possible_truncation "casting `i32` to `i16` may truncate the value"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1210:36 clippy::cast_possible_truncation "casting `i32` to `i16` may truncate the value"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1235:39 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1236:41 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1274:42 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1324:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1333:37 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1334:35 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1346:34 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1346:34 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1346:34 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1347:37 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1347:37 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1347:37 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1348:36 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1348:36 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1348:36 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1349:37 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1349:37 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1349:37 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1350:35 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1350:35 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1350:35 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1351:36 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1351:36 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1351:36 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1352:31 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1352:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1352:31 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1419:36 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1420:36 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1421:36 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1422:36 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1423:36 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1490:37 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1561:46 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1562:45 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1567:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1568:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1586:26 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1587:34 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1588:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1589:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1897:38 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1898:51 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1900:39 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1969:34 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1970:34 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1971:36 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1972:36 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1973:36 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1974:37 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1975:37 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1976:36 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1977:36 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1978:39 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1979:39 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1980:39 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1981:39 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1982:39 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1983:39 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1984:38 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1985:38 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1986:35 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1987:35 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1988:35 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1989:35 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1990:38 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1991:37 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1992:37 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1993:38 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1994:37 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1995:37 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1996:37 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1997:37 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1998:33 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:1999:33 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2000:33 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2001:34 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2002:34 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2003:34 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2004:35 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2005:35 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2032:30 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2033:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2034:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2035:29 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2036:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2037:28 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2038:27 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2039:29 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2041:29 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2042:28 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2043:27 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2044:34 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2045:27 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2046:33 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2048:28 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2049:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2050:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2051:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2052:26 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2053:36 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2318:42 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2321:38 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2331:39 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2487:42 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2488:42 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2489:43 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2490:43 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2491:43 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2493:47 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2494:44 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2495:46 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2496:47 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2497:49 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2498:48 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2499:50 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2500:45 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2572:9 clippy::needless_return "unneeded `return` statement"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2578:20 clippy::zero_ptr "`0 as *mut _` detected"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2588:13 clippy::zero_ptr "`0 as *mut _` detected"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2590:13 clippy::ptr_as_ptr "`as` casting between raw pointers without changing its mutability"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2596:52 clippy::used_underscore_binding "used binding `_dummy` which is prefixed with an underscore. A leading underscore signals that a binding will not be used."
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2597:11 clippy::cast_sign_loss "casting `i32` to `usize` may lose the sign of the value"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2601:21 clippy::explicit_iter_loop "it is more concise to loop over references to containers instead of using explicit iteration methods"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2611:9 clippy::unused_unit "unneeded unit expression"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2619:9 clippy::unused_unit "unneeded unit expression"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2634:9 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2647:25 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2648:25 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2649:9 clippy::cast_possible_truncation "casting `u64` to `u32` may truncate the value"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2654:18 clippy::identity_op "the operation is ineffective. Consider reducing it to `(dev & 0x00000000000000ff)`"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2654:25 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2655:25 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2656:9 clippy::cast_possible_truncation "casting `u64` to `u32` may truncate the value"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2660:21 clippy::cast_lossless "casting `u32` to `u64` may become silently lossy if you later change the type"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2661:21 clippy::cast_lossless "casting `u32` to `u64` may become silently lossy if you later change the type"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2663:25 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2664:25 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2665:16 clippy::identity_op "the operation is ineffective. Consider reducing it to `(minor & 0x000000ff)`"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2665:25 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:2666:25 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/linux/mod.rs:954:34 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1000:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1001:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1002:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1016:29 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1017:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1018:33 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1019:33 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1020:33 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1029:29 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1030:29 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1031:30 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1032:29 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1033:29 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1034:29 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1035:29 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1041:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1042:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1043:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1044:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1045:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1046:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1047:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1048:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1049:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1050:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1051:33 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1053:29 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1054:33 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1055:30 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1056:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1057:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1058:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1059:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1060:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1073:42 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1074:43 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1075:37 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1076:37 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1077:41 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1078:35 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1079:35 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1080:36 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1081:35 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1082:35 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1083:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1084:38 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1086:30 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1087:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1089:30 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1090:33 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1091:30 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1094:40 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1095:37 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1096:41 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1097:40 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1098:39 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1099:34 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1100:36 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1101:38 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1102:37 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1105:44 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1106:41 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1107:42 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1108:42 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1109:41 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1110:46 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1111:41 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1112:44 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1113:40 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1114:47 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1115:36 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1126:34 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1127:29 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1128:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1179:32 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1180:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:1218:27 clippy::identity_op "the operation is ineffective. Consider reducing it to `IPOPT_CONTROL`"
-libc/0.2.81/src/unix/linux_like/mod.rs:1314:9 clippy::precedence "operator precedence can trip the unwary"
-libc/0.2.81/src/unix/linux_like/mod.rs:1321:13 clippy::ptr_as_ptr "`as` casting between raw pointers without changing its mutability"
-libc/0.2.81/src/unix/linux_like/mod.rs:1323:13 clippy::zero_ptr "`0 as *mut _` detected"
-libc/0.2.81/src/unix/linux_like/mod.rs:1332:9 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
-libc/0.2.81/src/unix/linux_like/mod.rs:1337:9 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
-libc/0.2.81/src/unix/linux_like/mod.rs:1341:18 clippy::cast_sign_loss "casting `i32` to `usize` may lose the sign of the value"
-libc/0.2.81/src/unix/linux_like/mod.rs:1344:9 clippy::needless_return "unneeded `return` statement"
-libc/0.2.81/src/unix/linux_like/mod.rs:1348:18 clippy::cast_sign_loss "casting `i32` to `usize` may lose the sign of the value"
-libc/0.2.81/src/unix/linux_like/mod.rs:1350:9 clippy::needless_return "unneeded `return` statement"
-libc/0.2.81/src/unix/linux_like/mod.rs:1354:18 clippy::cast_sign_loss "casting `i32` to `usize` may lose the sign of the value"
-libc/0.2.81/src/unix/linux_like/mod.rs:1357:9 clippy::needless_return "unneeded `return` statement"
-libc/0.2.81/src/unix/linux_like/mod.rs:1361:21 clippy::explicit_iter_loop "it is more concise to loop over references to containers instead of using explicit iteration methods"
-libc/0.2.81/src/unix/linux_like/mod.rs:1381:9 clippy::cast_possible_truncation "casting `i32` to `i8` may truncate the value"
-libc/0.2.81/src/unix/linux_like/mod.rs:1389:9 clippy::verbose_bit_mask "bit mask could be simplified with a call to `trailing_zeros`"
-libc/0.2.81/src/unix/linux_like/mod.rs:446:31 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:591:36 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:592:38 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:593:35 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:594:33 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:595:34 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:596:36 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:597:37 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:598:37 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:599:39 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:600:34 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:601:35 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:602:35 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:607:37 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:608:35 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:764:35 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:765:39 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/linux_like/mod.rs:991:30 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/mod.rs:198:29 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/mod.rs:199:28 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/mod.rs:201:35 clippy::unnecessary_cast "casting integer literal to `usize` is unnecessary"
-libc/0.2.81/src/unix/mod.rs:202:35 clippy::unnecessary_cast "casting integer literal to `usize` is unnecessary"
-libc/0.2.81/src/unix/mod.rs:282:40 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/mod.rs:284:41 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/mod.rs:285:36 clippy::unreadable_literal "long literal lacking separators"
-libc/0.2.81/src/unix/mod.rs:34:10 clippy::upper_case_acronyms "name `DIR` contains a capitalized acronym"
-libc/0.2.81/src/unix/mod.rs:386:10 clippy::upper_case_acronyms "name `FILE` contains a capitalized acronym"
-log/0.4.11/src/lib.rs:1047:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-log/0.4.11/src/lib.rs:1053:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-log/0.4.11/src/lib.rs:1059:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-log/0.4.11/src/lib.rs:1093:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-log/0.4.11/src/lib.rs:1093:5 clippy::new_without_default "you should consider adding a `Default` implementation for `MetadataBuilder<'a>`"
-log/0.4.11/src/lib.rs:1118:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-log/0.4.11/src/lib.rs:1177:1 clippy::inline_always "you have declared `#[inline(always)]` on `max_level`. This is usually a bad idea"
-log/0.4.11/src/lib.rs:1178:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-log/0.4.11/src/lib.rs:1306:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-log/0.4.11/src/lib.rs:1358:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-log/0.4.11/src/lib.rs:1359:5 clippy::if_not_else "unnecessary `!=` operation"
-log/0.4.11/src/lib.rs:1407:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-log/0.4.11/src/lib.rs:329:27 clippy::derive_hash_xor_eq "you are deriving `Hash` but have implemented `PartialEq` explicitly"
-log/0.4.11/src/lib.rs:356:1 clippy::expl_impl_clone_on_copy "you are implementing `Clone` explicitly on a `Copy` type"
-log/0.4.11/src/lib.rs:448:12 clippy::manual_range_contains "manual `RangeInclusive::contains` implementation"
-log/0.4.11/src/lib.rs:500:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-log/0.4.11/src/lib.rs:506:28 clippy::trivially_copy_pass_by_ref "this argument (8 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
-log/0.4.11/src/lib.rs:506:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-log/0.4.11/src/lib.rs:520:27 clippy::derive_hash_xor_eq "you are deriving `Hash` but have implemented `PartialEq` explicitly"
-log/0.4.11/src/lib.rs:538:1 clippy::expl_impl_clone_on_copy "you are implementing `Clone` explicitly on a `Copy` type"
-log/0.4.11/src/lib.rs:653:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-log/0.4.11/src/lib.rs:661:21 clippy::trivially_copy_pass_by_ref "this argument (8 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
-log/0.4.11/src/lib.rs:661:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-log/0.4.11/src/lib.rs:677:44 clippy::match_same_arms "this `match` has identical arm bodies"
-log/0.4.11/src/lib.rs:758:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-log/0.4.11/src/lib.rs:764:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-log/0.4.11/src/lib.rs:770:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-log/0.4.11/src/lib.rs:776:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-log/0.4.11/src/lib.rs:782:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-log/0.4.11/src/lib.rs:788:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-log/0.4.11/src/lib.rs:794:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-log/0.4.11/src/lib.rs:803:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-log/0.4.11/src/lib.rs:809:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-log/0.4.11/src/lib.rs:818:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-log/0.4.11/src/lib.rs:908:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-log/0.4.11/src/lib.rs:908:5 clippy::new_without_default "you should consider adding a `Default` implementation for `RecordBuilder<'a>`"
-log/0.4.11/src/lib.rs:995:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-proc-macro2/1.0.24/src/detection.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-proc-macro2/1.0.24/src/fallback.rs:108:17 clippy::match_wildcard_for_single_variants "wildcard match will miss any future added variants"
-proc-macro2/1.0.24/src/fallback.rs:269:20 clippy::unused_self "unused `self` argument"
-proc-macro2/1.0.24/src/fallback.rs:430:24 clippy::trivially_copy_pass_by_ref "this argument (0 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
-proc-macro2/1.0.24/src/fallback.rs:437:23 clippy::trivially_copy_pass_by_ref "this argument (0 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
-proc-macro2/1.0.24/src/fallback.rs:437:23 clippy::unused_self "unused `self` argument"
-proc-macro2/1.0.24/src/fallback.rs:471:17 clippy::trivially_copy_pass_by_ref "this argument (0 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
-proc-macro2/1.0.24/src/fallback.rs:471:17 clippy::unused_self "unused `self` argument"
-proc-macro2/1.0.24/src/fallback.rs:654:5 clippy::manual_range_contains "manual `RangeInclusive::contains` implementation"
-proc-macro2/1.0.24/src/fallback.rs:655:12 clippy::manual_range_contains "manual `RangeInclusive::contains` implementation"
-proc-macro2/1.0.24/src/fallback.rs:661:5 clippy::manual_range_contains "manual `RangeInclusive::contains` implementation"
-proc-macro2/1.0.24/src/fallback.rs:662:12 clippy::manual_range_contains "manual `RangeInclusive::contains` implementation"
-proc-macro2/1.0.24/src/fallback.rs:664:12 clippy::manual_range_contains "manual `RangeInclusive::contains` implementation"
-proc-macro2/1.0.24/src/fallback.rs:674:37 clippy::manual_range_contains "manual `RangeInclusive::contains` implementation"
-proc-macro2/1.0.24/src/fallback.rs:678:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-proc-macro2/1.0.24/src/fallback.rs:85:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-proc-macro2/1.0.24/src/fallback.rs:882:43 clippy::unused_self "unused `self` argument"
-proc-macro2/1.0.24/src/lib.rs:1017:9 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-proc-macro2/1.0.24/src/lib.rs:1081:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-proc-macro2/1.0.24/src/lib.rs:1099:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-proc-macro2/1.0.24/src/lib.rs:1117:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-proc-macro2/1.0.24/src/lib.rs:1135:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-proc-macro2/1.0.24/src/lib.rs:1141:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-proc-macro2/1.0.24/src/lib.rs:1146:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-proc-macro2/1.0.24/src/lib.rs:1151:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-proc-macro2/1.0.24/src/lib.rs:1156:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-proc-macro2/1.0.24/src/lib.rs:152:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-proc-macro2/1.0.24/src/lib.rs:157:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-proc-macro2/1.0.24/src/lib.rs:373:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-proc-macro2/1.0.24/src/lib.rs:383:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-proc-macro2/1.0.24/src/lib.rs:397:24 clippy::trivially_copy_pass_by_ref "this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
-proc-macro2/1.0.24/src/lib.rs:397:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-proc-macro2/1.0.24/src/lib.rs:403:23 clippy::trivially_copy_pass_by_ref "this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
-proc-macro2/1.0.24/src/lib.rs:403:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-proc-macro2/1.0.24/src/lib.rs:418:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-proc-macro2/1.0.24/src/lib.rs:425:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-proc-macro2/1.0.24/src/lib.rs:464:17 clippy::trivially_copy_pass_by_ref "this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
-proc-macro2/1.0.24/src/lib.rs:500:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-proc-macro2/1.0.24/src/lib.rs:626:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-proc-macro2/1.0.24/src/lib.rs:633:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-proc-macro2/1.0.24/src/lib.rs:641:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-proc-macro2/1.0.24/src/lib.rs:652:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-proc-macro2/1.0.24/src/lib.rs:662:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-proc-macro2/1.0.24/src/lib.rs:672:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-proc-macro2/1.0.24/src/lib.rs:734:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-proc-macro2/1.0.24/src/lib.rs:743:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-proc-macro2/1.0.24/src/lib.rs:752:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-proc-macro2/1.0.24/src/lib.rs:757:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-proc-macro2/1.0.24/src/lib.rs:788:19 clippy::doc_markdown "you should put `XID_Start` between ticks in the documentation"
-proc-macro2/1.0.24/src/lib.rs:788:69 clippy::doc_markdown "you should put `XID_Continue` between ticks in the documentation"
-proc-macro2/1.0.24/src/lib.rs:891:36 clippy::doc_markdown "you should put `syn::parse_str` between ticks in the documentation"
-proc-macro2/1.0.24/src/lib.rs:894:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-proc-macro2/1.0.24/src/lib.rs:911:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-proc-macro2/1.0.24/src/lib.rs:996:9 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-proc-macro2/1.0.24/src/parse.rs:552:5 clippy::while_let_on_iterator "this loop could be written as a `for` loop"
-proc-macro2/1.0.24/src/parse.rs:584:21 clippy::manual_range_contains "manual `RangeInclusive::contains` implementation"
-proc-macro2/1.0.24/src/parse.rs:602:20 clippy::map_unwrap_or "called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead"
-proc-macro2/1.0.24/src/parse.rs:696:29 clippy::cast_lossless "casting `u8` to `u64` may become silently lossy if you later change the type"
-proc-macro2/1.0.24/src/parse.rs:702:34 clippy::cast_lossless "casting `u8` to `u64` may become silently lossy if you later change the type"
-proc-macro2/1.0.24/src/parse.rs:708:34 clippy::cast_lossless "casting `u8` to `u64` may become silently lossy if you later change the type"
-proc-macro2/1.0.24/src/parse.rs:793:5 clippy::vec_init_then_push "calls to `push` immediately after creation"
-proc-macro2/1.0.24/src/parse.rs:803:15 clippy::explicit_iter_loop "it is more concise to loop over references to containers instead of using explicit iteration methods"
-proc-macro2/1.0.24/src/parse.rs:808:15 clippy::explicit_iter_loop "it is more concise to loop over references to containers instead of using explicit iteration methods"
-proc-macro2/1.0.24/src/wrapper.rs:415:24 clippy::trivially_copy_pass_by_ref "this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
-proc-macro2/1.0.24/src/wrapper.rs:429:23 clippy::trivially_copy_pass_by_ref "this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
-proc-macro2/1.0.24/src/wrapper.rs:492:17 clippy::trivially_copy_pass_by_ref "this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
-quote/1.0.7/src/ext.rs:10:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-quote/1.0.7/src/ext.rs:7:5 clippy::doc_markdown "you should put `TokenStream` between ticks in the documentation"
-quote/1.0.7/src/ident_fragment.rs:13:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-quote/1.0.7/src/ident_fragment.rs:51:31 clippy::manual_strip "stripping a prefix manually"
-quote/1.0.7/src/runtime.rs:52:5 clippy::module_name_repetitions "item name ends with its containing module's name"
-quote/1.0.7/src/runtime.rs:63:5 clippy::module_name_repetitions "item name ends with its containing module's name"
-quote/1.0.7/src/runtime.rs:66:33 clippy::doc_markdown "you should put `DoesNotHaveIter` between ticks in the documentation"
-quote/1.0.7/src/runtime.rs:80:5 clippy::module_name_repetitions "item name ends with its containing module's name"
-rand/0.7.3/src/distributions/bernoulli.rs:103:20 clippy::cast_possible_truncation "casting `f64` to `u64` may truncate the value"
-rand/0.7.3/src/distributions/bernoulli.rs:103:20 clippy::cast_sign_loss "casting `f64` to `u64` may lose the sign of the value"
-rand/0.7.3/src/distributions/bernoulli.rs:116:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-rand/0.7.3/src/distributions/bernoulli.rs:123:21 clippy::cast_possible_truncation "casting `f64` to `u64` may truncate the value"
-rand/0.7.3/src/distributions/bernoulli.rs:123:21 clippy::cast_sign_loss "casting `f64` to `u64` may lose the sign of the value"
-rand/0.7.3/src/distributions/bernoulli.rs:63:26 clippy::cast_precision_loss "casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
-rand/0.7.3/src/distributions/bernoulli.rs:63:27 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-rand/0.7.3/src/distributions/bernoulli.rs:67:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-rand/0.7.3/src/distributions/bernoulli.rs:95:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-rand/0.7.3/src/distributions/bernoulli.rs:96:13 clippy::manual_range_contains "manual `Range::contains` implementation"
-rand/0.7.3/src/distributions/binomial.rs:107:23 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
-rand/0.7.3/src/distributions/binomial.rs:112:44 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
-rand/0.7.3/src/distributions/binomial.rs:116:13 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rand/0.7.3/src/distributions/binomial.rs:150:28 clippy::redundant_else "redundant else block"
-rand/0.7.3/src/distributions/binomial.rs:153:24 clippy::if_not_else "unnecessary boolean `not` operation"
-rand/0.7.3/src/distributions/binomial.rs:158:28 clippy::redundant_else "redundant else block"
-rand/0.7.3/src/distributions/binomial.rs:164:33 clippy::cast_sign_loss "casting `i64` to `u64` may lose the sign of the value"
-rand/0.7.3/src/distributions/binomial.rs:166:28 clippy::redundant_else "redundant else block"
-rand/0.7.3/src/distributions/binomial.rs:175:47 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
-rand/0.7.3/src/distributions/binomial.rs:185:38 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
-rand/0.7.3/src/distributions/binomial.rs:194:38 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
-rand/0.7.3/src/distributions/binomial.rs:202:28 clippy::redundant_else "redundant else block"
-rand/0.7.3/src/distributions/binomial.rs:209:25 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
-rand/0.7.3/src/distributions/binomial.rs:221:26 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
-rand/0.7.3/src/distributions/binomial.rs:222:26 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
-rand/0.7.3/src/distributions/binomial.rs:223:25 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
-rand/0.7.3/src/distributions/binomial.rs:224:25 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
-rand/0.7.3/src/distributions/binomial.rs:226:17 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rand/0.7.3/src/distributions/binomial.rs:233:32 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
-rand/0.7.3/src/distributions/binomial.rs:234:27 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
-rand/0.7.3/src/distributions/binomial.rs:251:22 clippy::cast_sign_loss "casting `i64` to `u64` may lose the sign of the value"
-rand/0.7.3/src/distributions/binomial.rs:255:9 clippy::if_not_else "unnecessary `!=` operation"
-rand/0.7.3/src/distributions/binomial.rs:35:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-rand/0.7.3/src/distributions/binomial.rs:45:17 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
-rand/0.7.3/src/distributions/binomial.rs:46:5 clippy::cast_possible_truncation "casting `f64` to `i64` may truncate the value"
-rand/0.7.3/src/distributions/binomial.rs:50:5 clippy::too_many_lines "this function has too many lines (143/100)"
-rand/0.7.3/src/distributions/binomial.rs:76:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rand/0.7.3/src/distributions/binomial.rs:78:12 clippy::cast_precision_loss "casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
-rand/0.7.3/src/distributions/binomial.rs:81:21 clippy::cast_precision_loss "casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
-rand/0.7.3/src/distributions/binomial.rs:82:32 clippy::cast_possible_truncation "casting `u64` to `i32` may truncate the value"
-rand/0.7.3/src/distributions/binomial.rs:88:26 clippy::cast_precision_loss "casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
-rand/0.7.3/src/distributions/binomial.rs:99:21 clippy::cast_precision_loss "casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
-rand/0.7.3/src/distributions/cauchy.rs:33:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-rand/0.7.3/src/distributions/dirichlet.rs:52:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-rand/0.7.3/src/distributions/dirichlet.rs:64:32 clippy::unseparated_literal_suffix "float type suffix should be separated by an underscore"
-rand/0.7.3/src/distributions/dirichlet.rs:65:23 clippy::unseparated_literal_suffix "float type suffix should be separated by an underscore"
-rand/0.7.3/src/distributions/exponential.rs:76:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-rand/0.7.3/src/distributions/float.rs:73:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-rand/0.7.3/src/distributions/gamma.rs:13:5 clippy::enum_glob_use "usage of wildcard import for enum variants"
-rand/0.7.3/src/distributions/gamma.rs:14:5 clippy::enum_glob_use "usage of wildcard import for enum variants"
-rand/0.7.3/src/distributions/gamma.rs:189:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-rand/0.7.3/src/distributions/gamma.rs:230:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-rand/0.7.3/src/distributions/gamma.rs:259:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-rand/0.7.3/src/distributions/gamma.rs:287:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-rand/0.7.3/src/distributions/gamma.rs:90:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-rand/0.7.3/src/distributions/integer.rs:23:9 clippy::cast_possible_truncation "casting `u32` to `u8` may truncate the value"
-rand/0.7.3/src/distributions/integer.rs:30:9 clippy::cast_possible_truncation "casting `u32` to `u16` may truncate the value"
-rand/0.7.3/src/distributions/integer.rs:69:9 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
-rand/0.7.3/src/distributions/mod.rs:263:5 clippy::inline_always "you have declared `#[inline(always)]` on `next`. This is usually a bad idea"
-rand/0.7.3/src/distributions/normal.rs:100:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-rand/0.7.3/src/distributions/normal.rs:119:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-rand/0.7.3/src/distributions/normal.rs:131:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-rand/0.7.3/src/distributions/normal.rs:31:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-rand/0.7.3/src/distributions/normal.rs:47:25 clippy::unseparated_literal_suffix "float type suffix should be separated by an underscore"
-rand/0.7.3/src/distributions/normal.rs:48:25 clippy::unseparated_literal_suffix "float type suffix should be separated by an underscore"
-rand/0.7.3/src/distributions/other.rs:89:9 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
-rand/0.7.3/src/distributions/pareto.rs:32:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-rand/0.7.3/src/distributions/poisson.rs:35:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-rand/0.7.3/src/distributions/poisson.rs:87:30 clippy::cast_possible_truncation "casting `f64` to `u64` may truncate the value"
-rand/0.7.3/src/distributions/poisson.rs:87:30 clippy::cast_sign_loss "casting `f64` to `u64` may lose the sign of the value"
-rand/0.7.3/src/distributions/triangular.rs:32:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-rand/0.7.3/src/distributions/uniform.rs:146:4 clippy::needless_doctest_main "needless `fn main` in doctest"
-rand/0.7.3/src/distributions/uniform.rs:199:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-rand/0.7.3/src/distributions/uniform.rs:214:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-rand/0.7.3/src/distributions/uniform.rs:283:14 clippy::doc_markdown "you should put `SampleUniform` between ticks in the documentation"
-rand/0.7.3/src/distributions/uniform.rs:283:46 clippy::doc_markdown "you should put `SampleUniform` between ticks in the documentation"
-rand/0.7.3/src/distributions/uniform.rs:296:5 clippy::inline_always "you have declared `#[inline(always)]` on `borrow`. This is usually a bad idea"
-rand/0.7.3/src/distributions/uniform.rs:304:5 clippy::inline_always "you have declared `#[inline(always)]` on `borrow`. This is usually a bad idea"
-rand/0.7.3/src/distributions/uniform.rs:350:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-rand/0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
-rand/0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
-rand/0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
-rand/0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
-rand/0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
-rand/0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
-rand/0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
-rand/0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
-rand/0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
-rand/0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
-rand/0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
-rand/0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
-rand/0.7.3/src/distributions/uniform.rs:441:31 clippy::invalid_upcast_comparisons "because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false"
-rand/0.7.3/src/distributions/uniform.rs:441:31 clippy::invalid_upcast_comparisons "because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false"
-rand/0.7.3/src/distributions/uniform.rs:441:31 clippy::invalid_upcast_comparisons "because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false"
-rand/0.7.3/src/distributions/uniform.rs:441:31 clippy::invalid_upcast_comparisons "because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false"
-rand/0.7.3/src/distributions/uniform.rs:441:31 clippy::invalid_upcast_comparisons "because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false"
-rand/0.7.3/src/distributions/uniform.rs:441:31 clippy::invalid_upcast_comparisons "because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false"
-rand/0.7.3/src/distributions/uniform.rs:441:31 clippy::invalid_upcast_comparisons "because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false"
-rand/0.7.3/src/distributions/uniform.rs:441:31 clippy::invalid_upcast_comparisons "because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false"
-rand/0.7.3/src/distributions/uniform.rs:56:10 clippy::doc_markdown "you should put `SampleBorrow` between ticks in the documentation"
-rand/0.7.3/src/distributions/uniform.rs:647:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-rand/0.7.3/src/distributions/uniform.rs:840:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-rand/0.7.3/src/distributions/uniform.rs:913:13 clippy::option_if_let_else "use Option::map_or_else instead of an if let/else"
-rand/0.7.3/src/distributions/uniform.rs:943:54 clippy::cast_possible_truncation "casting `u64` to `u32` may truncate the value"
-rand/0.7.3/src/distributions/unit_circle.rs:30:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-rand/0.7.3/src/distributions/unit_sphere.rs:24:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-rand/0.7.3/src/distributions/unit_sphere.rs:29:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-rand/0.7.3/src/distributions/utils.rs:218:18 clippy::upper_case_acronyms "name `FloatSIMDUtils` contains a capitalized acronym"
-rand/0.7.3/src/distributions/utils.rs:247:15 clippy::wrong_self_convention "methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name"
-rand/0.7.3/src/distributions/utils.rs:248:20 clippy::wrong_self_convention "methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name"
-rand/0.7.3/src/distributions/utils.rs:249:18 clippy::wrong_self_convention "methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name"
-rand/0.7.3/src/distributions/utils.rs:253:18 clippy::upper_case_acronyms "name `FloatAsSIMD` contains a capitalized acronym"
-rand/0.7.3/src/distributions/utils.rs:254:5 clippy::inline_always "you have declared `#[inline(always)]` on `lanes`. This is usually a bad idea"
-rand/0.7.3/src/distributions/utils.rs:258:5 clippy::inline_always "you have declared `#[inline(always)]` on `splat`. This is usually a bad idea"
-rand/0.7.3/src/distributions/utils.rs:262:5 clippy::inline_always "you have declared `#[inline(always)]` on `extract`. This is usually a bad idea"
-rand/0.7.3/src/distributions/utils.rs:267:5 clippy::inline_always "you have declared `#[inline(always)]` on `replace`. This is usually a bad idea"
-rand/0.7.3/src/distributions/utils.rs:274:18 clippy::upper_case_acronyms "name `BoolAsSIMD` contains a capitalized acronym"
-rand/0.7.3/src/distributions/utils.rs:281:5 clippy::inline_always "you have declared `#[inline(always)]` on `any`. This is usually a bad idea"
-rand/0.7.3/src/distributions/utils.rs:286:5 clippy::inline_always "you have declared `#[inline(always)]` on `all`. This is usually a bad idea"
-rand/0.7.3/src/distributions/utils.rs:291:5 clippy::inline_always "you have declared `#[inline(always)]` on `none`. This is usually a bad idea"
-rand/0.7.3/src/distributions/utils.rs:488:17 clippy::doc_markdown "you should put `x_i` between ticks in the documentation"
-rand/0.7.3/src/distributions/utils.rs:489:50 clippy::doc_markdown "you should put `x_i` between ticks in the documentation"
-rand/0.7.3/src/distributions/utils.rs:489:63 clippy::doc_markdown "you should put `f(x_i` between ticks in the documentation"
-rand/0.7.3/src/distributions/utils.rs:490:40 clippy::doc_markdown "you should put `f(x_i` between ticks in the documentation"
-rand/0.7.3/src/distributions/utils.rs:490:49 clippy::doc_markdown "you should put `f(x_{i+1` between ticks in the documentation"
-rand/0.7.3/src/distributions/utils.rs:518:17 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
-rand/0.7.3/src/distributions/weibull.rs:29:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-rand/0.7.3/src/distributions/weighted/alias_method.rs:113:21 clippy::explicit_iter_loop "it is more concise to loop over references to containers instead of using explicit iteration methods"
-rand/0.7.3/src/distributions/weighted/alias_method.rs:125:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rand/0.7.3/src/distributions/weighted/alias_method.rs:131:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rand/0.7.3/src/distributions/weighted/alias_method.rs:180:36 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
-rand/0.7.3/src/distributions/weighted/alias_method.rs:182:34 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
-rand/0.7.3/src/distributions/weighted/alias_method.rs:259:28 clippy::clone_on_copy "using `clone` on type `distributions::uniform::Uniform<u32>` which implements the `Copy` trait"
-rand/0.7.3/src/distributions/weighted/alias_method.rs:296:9 clippy::map_clone "you are using an explicit closure for copying elements"
-rand/0.7.3/src/distributions/weighted/alias_method.rs:321:9 clippy::map_clone "you are using an explicit closure for copying elements"
-rand/0.7.3/src/distributions/weighted/alias_method.rs:78:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-rand/0.7.3/src/distributions/weighted/alias_method.rs:78:5 clippy::too_many_lines "this function has too many lines (106/100)"
-rand/0.7.3/src/distributions/weighted/alias_method.rs:85:17 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
-rand/0.7.3/src/distributions/weighted/alias_method.rs:87:31 clippy::map_unwrap_or "called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead"
-rand/0.7.3/src/distributions/weighted/mod.rs:100:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-rand/0.7.3/src/distributions/weighted/mod.rs:144:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-rand/0.7.3/src/distributions/weighted/mod.rs:169:16 clippy::int_plus_one "unnecessary `>= y + 1` or `x - 1 >=`"
-rand/0.7.3/src/distributions/weighted/mod.rs:386:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-rand/0.7.3/src/distributions/weighted/mod.rs:85:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-rand/0.7.3/src/lib.rs:333:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-rand/0.7.3/src/lib.rs:404:14 clippy::wrong_self_convention "methods called `to_*` usually take self by reference; consider choosing a less ambiguous name"
-rand/0.7.3/src/lib.rs:552:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-rand/0.7.3/src/rngs/adapter/read.rs:47:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-rand/0.7.3/src/rngs/adapter/read.rs:89:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-rand/0.7.3/src/rngs/adapter/reseeding.rs:100:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-rand/0.7.3/src/rngs/adapter/reseeding.rs:112:5 clippy::inline_always "you have declared `#[inline(always)]` on `next_u32`. This is usually a bad idea"
-rand/0.7.3/src/rngs/adapter/reseeding.rs:117:5 clippy::inline_always "you have declared `#[inline(always)]` on `next_u64`. This is usually a bad idea"
-rand/0.7.3/src/rngs/adapter/reseeding.rs:198:13 clippy::cast_possible_wrap "casting `u64` to `i64` may wrap around the value"
-rand/0.7.3/src/rngs/adapter/reseeding.rs:231:9 clippy::cast_possible_wrap "casting `usize` to `isize` may wrap around the value"
-rand/0.7.3/src/rngs/adapter/reseeding.rs:27:28 clippy::doc_markdown "you should put `ChaCha` between ticks in the documentation"
-rand/0.7.3/src/rngs/adapter/reseeding.rs:79:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-rand/0.7.3/src/rngs/entropy.rs:24:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-rand/0.7.3/src/rngs/entropy.rs:34:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-rand/0.7.3/src/rngs/mock.rs:36:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-rand/0.7.3/src/rngs/mock.rs:47:9 clippy::cast_possible_truncation "casting `u64` to `u32` may truncate the value"
-rand/0.7.3/src/rngs/mod.rs:61:74 clippy::doc_markdown "you should put `ChaCha20` between ticks in the documentation"
-rand/0.7.3/src/rngs/std.rs:25:39 clippy::doc_markdown "you should put `ChaCha` between ticks in the documentation"
-rand/0.7.3/src/rngs/std.rs:32:10 clippy::doc_markdown "you should put `rand_chacha` between ticks in the documentation"
-rand/0.7.3/src/rngs/std.rs:36:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-rand/0.7.3/src/rngs/std.rs:39:5 clippy::inline_always "you have declared `#[inline(always)]` on `next_u32`. This is usually a bad idea"
-rand/0.7.3/src/rngs/std.rs:44:5 clippy::inline_always "you have declared `#[inline(always)]` on `next_u64`. This is usually a bad idea"
-rand/0.7.3/src/rngs/std.rs:49:5 clippy::inline_always "you have declared `#[inline(always)]` on `fill_bytes`. This is usually a bad idea"
-rand/0.7.3/src/rngs/std.rs:54:5 clippy::inline_always "you have declared `#[inline(always)]` on `try_fill_bytes`. This is usually a bad idea"
-rand/0.7.3/src/rngs/std.rs:63:5 clippy::inline_always "you have declared `#[inline(always)]` on `from_seed`. This is usually a bad idea"
-rand/0.7.3/src/rngs/std.rs:68:5 clippy::inline_always "you have declared `#[inline(always)]` on `from_rng`. This is usually a bad idea"
-rand/0.7.3/src/rngs/thread.rs:57:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-rand/0.7.3/src/rngs/thread.rs:80:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-rand/0.7.3/src/rngs/thread.rs:80:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-rand/0.7.3/src/rngs/thread.rs:81:35 clippy::redundant_closure_for_method_calls "redundant closure found"
-rand/0.7.3/src/rngs/thread.rs:93:5 clippy::inline_always "you have declared `#[inline(always)]` on `next_u32`. This is usually a bad idea"
-rand/0.7.3/src/rngs/thread.rs:98:5 clippy::inline_always "you have declared `#[inline(always)]` on `next_u64`. This is usually a bad idea"
-rand/0.7.3/src/seq/index.rs:127:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-rand/0.7.3/src/seq/index.rs:139:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
-rand/0.7.3/src/seq/index.rs:159:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-rand/0.7.3/src/seq/index.rs:171:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
-rand/0.7.3/src/seq/index.rs:180:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
-rand/0.7.3/src/seq/index.rs:223:18 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
-rand/0.7.3/src/seq/index.rs:224:18 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
-rand/0.7.3/src/seq/index.rs:233:25 clippy::cast_precision_loss "casting `u32` to `f32` causes a loss of precision (`u32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)"
-rand/0.7.3/src/seq/index.rs:236:27 clippy::cast_precision_loss "casting `u32` to `f32` causes a loss of precision (`u32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)"
-rand/0.7.3/src/seq/index.rs:244:12 clippy::cast_precision_loss "casting `u32` to `f32` causes a loss of precision (`u32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)"
-rand/0.7.3/src/seq/index.rs:244:37 clippy::cast_precision_loss "casting `u32` to `f32` causes a loss of precision (`u32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)"
-rand/0.7.3/src/seq/index.rs:29:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-rand/0.7.3/src/seq/index.rs:39:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-rand/0.7.3/src/seq/index.rs:48:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-rand/0.7.3/src/seq/index.rs:60:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-rand/0.7.3/src/seq/index.rs:69:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-rand/0.7.3/src/seq/index.rs:78:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-rand/0.7.3/src/seq/index.rs:87:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-rand/0.7.3/src/seq/index.rs:87:5 clippy::should_implement_trait "method `into_iter` can be confused for the standard trait method `std::iter::IntoIterator::into_iter`"
-rand/0.7.3/src/seq/index.rs:97:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
-rand/0.7.3/src/seq/mod.rs:141:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-rand/0.7.3/src/seq/mod.rs:168:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-rand/0.7.3/src/seq/mod.rs:229:4 clippy::needless_doctest_main "needless `fn main` in doctest"
-rand/0.7.3/src/seq/mod.rs:292:29 clippy::cast_precision_loss "casting `usize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`usize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
-rand/0.7.3/src/seq/mod.rs:410:23 clippy::default_trait_access "calling `std::marker::PhantomData::default()` is more clear than this expression"
-rand/0.7.3/src/seq/mod.rs:45:4 clippy::needless_doctest_main "needless `fn main` in doctest"
-rand/0.7.3/src/seq/mod.rs:527:26 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
-rand_core/0.6.0/src/block.rs:117:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-rand_core/0.6.0/src/block.rs:153:5 clippy::inline_always "you have declared `#[inline(always)]` on `index`. This is usually a bad idea"
-rand_core/0.6.0/src/block.rs:230:5 clippy::inline_always "you have declared `#[inline(always)]` on `try_fill_bytes`. This is usually a bad idea"
-rand_core/0.6.0/src/block.rs:240:5 clippy::inline_always "you have declared `#[inline(always)]` on `from_seed`. This is usually a bad idea"
-rand_core/0.6.0/src/block.rs:245:5 clippy::inline_always "you have declared `#[inline(always)]` on `seed_from_u64`. This is usually a bad idea"
-rand_core/0.6.0/src/block.rs:250:5 clippy::inline_always "you have declared `#[inline(always)]` on `from_rng`. This is usually a bad idea"
-rand_core/0.6.0/src/block.rs:280:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-rand_core/0.6.0/src/block.rs:319:5 clippy::inline_always "you have declared `#[inline(always)]` on `index`. This is usually a bad idea"
-rand_core/0.6.0/src/block.rs:405:5 clippy::inline_always "you have declared `#[inline(always)]` on `try_fill_bytes`. This is usually a bad idea"
-rand_core/0.6.0/src/block.rs:415:5 clippy::inline_always "you have declared `#[inline(always)]` on `from_seed`. This is usually a bad idea"
-rand_core/0.6.0/src/block.rs:420:5 clippy::inline_always "you have declared `#[inline(always)]` on `seed_from_u64`. This is usually a bad idea"
-rand_core/0.6.0/src/block.rs:425:5 clippy::inline_always "you have declared `#[inline(always)]` on `from_rng`. This is usually a bad idea"
-rand_core/0.6.0/src/block.rs:67:14 clippy::doc_markdown "you should put `module][crate::block` between ticks in the documentation"
-rand_core/0.6.0/src/block.rs:68:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-rand_core/0.6.0/src/error.rs:106:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-rand_core/0.6.0/src/error.rs:87:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-rand_core/0.6.0/src/error.rs:95:74 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
-rand_core/0.6.0/src/lib.rs:179:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-rand_core/0.6.0/src/lib.rs:301:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-rand_core/0.6.0/src/lib.rs:303:26 clippy::unreadable_literal "long literal lacking separators"
-rand_core/0.6.0/src/lib.rs:304:26 clippy::unreadable_literal "long literal lacking separators"
-rand_core/0.6.0/src/lib.rs:313:30 clippy::cast_possible_truncation "casting `u64` to `u32` may truncate the value"
-rand_core/0.6.0/src/lib.rs:314:23 clippy::cast_possible_truncation "casting `u64` to `u32` may truncate the value"
-rand_core/0.6.0/src/lib.rs:346:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-rand_core/0.6.0/src/lib.rs:381:5 clippy::inline_always "you have declared `#[inline(always)]` on `next_u32`. This is usually a bad idea"
-rand_core/0.6.0/src/lib.rs:386:5 clippy::inline_always "you have declared `#[inline(always)]` on `next_u64`. This is usually a bad idea"
-rand_core/0.6.0/src/lib.rs:391:5 clippy::inline_always "you have declared `#[inline(always)]` on `fill_bytes`. This is usually a bad idea"
-rand_core/0.6.0/src/lib.rs:396:5 clippy::inline_always "you have declared `#[inline(always)]` on `try_fill_bytes`. This is usually a bad idea"
-rayon/1.5.0/src/collections/binary_heap.rs:7:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/collections/binary_heap.rs:8:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/collections/btree_map.rs:7:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/collections/btree_map.rs:8:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/collections/btree_set.rs:7:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/collections/btree_set.rs:8:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/collections/hash_map.rs:10:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/collections/hash_map.rs:9:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/collections/hash_set.rs:10:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/collections/hash_set.rs:9:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/collections/linked_list.rs:7:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/collections/linked_list.rs:8:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/collections/mod.rs:59:32 clippy::mem_replace_with_default "replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`"
-rayon/1.5.0/src/collections/vec_deque.rs:8:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/collections/vec_deque.rs:9:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/compile_fail/cannot_collect_filtermap_data.rs:2:1 clippy::needless_doctest_main "needless `fn main` in doctest"
-rayon/1.5.0/src/compile_fail/cannot_zip_filtered_data.rs:2:1 clippy::needless_doctest_main "needless `fn main` in doctest"
-rayon/1.5.0/src/compile_fail/cell_par_iter.rs:2:1 clippy::needless_doctest_main "needless `fn main` in doctest"
-rayon/1.5.0/src/compile_fail/no_send_par_iter.rs:25:1 clippy::needless_doctest_main "needless `fn main` in doctest"
-rayon/1.5.0/src/compile_fail/no_send_par_iter.rs:46:1 clippy::needless_doctest_main "needless `fn main` in doctest"
-rayon/1.5.0/src/compile_fail/no_send_par_iter.rs:4:1 clippy::needless_doctest_main "needless `fn main` in doctest"
-rayon/1.5.0/src/compile_fail/rc_par_iter.rs:2:1 clippy::needless_doctest_main "needless `fn main` in doctest"
-rayon/1.5.0/src/iter/chain.rs:103:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/chain.rs:122:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/chain.rs:128:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/chain.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/chain.rs:221:36 clippy::doc_markdown "you should put `ExactSizeIterator` between ticks in the documentation"
-rayon/1.5.0/src/iter/chain.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/chain.rs:51:38 clippy::option_if_let_else "use Option::map_or_else instead of an if let/else"
-rayon/1.5.0/src/iter/chain.rs:58:14 clippy::shadow_unrelated "`a` is being shadowed"
-rayon/1.5.0/src/iter/chain.rs:58:17 clippy::shadow_unrelated "`b` is being shadowed"
-rayon/1.5.0/src/iter/chain.rs:78:14 clippy::shadow_unrelated "`a` is being shadowed"
-rayon/1.5.0/src/iter/chain.rs:78:17 clippy::shadow_unrelated "`b` is being shadowed"
-rayon/1.5.0/src/iter/chain.rs:97:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/chunks.rs:3:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/chunks.rs:4:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/chunks.rs:77:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/chunks.rs:83:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/cloned.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/cloned.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/cloned.rs:71:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/cloned.rs:75:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/collect/consumer.rs:141:5 clippy::doc_markdown "you should put `CollectReducer` between ticks in the documentation"
-rayon/1.5.0/src/iter/collect/consumer.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/collect/consumer.rs:28:5 clippy::doc_markdown "you should put `CollectResult` between ticks in the documentation"
-rayon/1.5.0/src/iter/collect/consumer.rs:36:37 clippy::mut_mut "generally you want to avoid `&mut &mut _` if possible"
-rayon/1.5.0/src/iter/collect/consumer.rs:36:37 clippy::mut_mut "generally you want to avoid `&mut &mut _` if possible"
-rayon/1.5.0/src/iter/collect/mod.rs:154:9 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-rayon/1.5.0/src/iter/copied.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/copied.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/copied.rs:71:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/copied.rs:75:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/empty.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/empty.rs:24:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-rayon/1.5.0/src/iter/empty.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/enumerate.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/enumerate.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/enumerate.rs:64:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/enumerate.rs:68:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/extend.rs:143:63 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
-rayon/1.5.0/src/iter/extend.rs:182:57 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
-rayon/1.5.0/src/iter/extend.rs:218:32 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
-rayon/1.5.0/src/iter/extend.rs:218:59 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
-rayon/1.5.0/src/iter/extend.rs:25:42 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
-rayon/1.5.0/src/iter/extend.rs:287:62 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
-rayon/1.5.0/src/iter/extend.rs:322:56 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
-rayon/1.5.0/src/iter/extend.rs:41:27 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
-rayon/1.5.0/src/iter/extend.rs:47:30 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
-rayon/1.5.0/src/iter/extend.rs:47:56 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
-rayon/1.5.0/src/iter/extend.rs:47:74 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
-rayon/1.5.0/src/iter/extend.rs:53:29 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
-rayon/1.5.0/src/iter/extend.rs:57:36 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
-rayon/1.5.0/src/iter/extend.rs:59:61 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
-rayon/1.5.0/src/iter/filter.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/filter.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/filter_map.rs:123:9 clippy::option_if_let_else "use Option::map_or instead of an if let/else"
-rayon/1.5.0/src/iter/filter_map.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/filter_map.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/find.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/find.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/find_first_last/mod.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/find_first_last/mod.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/find_first_last/mod.rs:32:67 clippy::doc_markdown "you should put `MatchPosition` between ticks in the documentation"
-rayon/1.5.0/src/iter/flat_map.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/flat_map.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/flat_map_iter.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/flat_map_iter.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/flatten.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/flatten.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/flatten_iter.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/flatten_iter.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/fold.rs:158:13 clippy::similar_names "binding's name is too similar to existing binding"
-rayon/1.5.0/src/iter/fold.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/fold.rs:204:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-rayon/1.5.0/src/iter/fold.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/for_each.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/for_each.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/inspect.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/inspect.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/inspect.rs:83:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/inspect.rs:88:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/interleave.rs:111:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/interleave.rs:119:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/interleave.rs:195:30 clippy::doc_markdown "you should put `self.i_len` between ticks in the documentation"
-rayon/1.5.0/src/iter/interleave.rs:195:43 clippy::doc_markdown "you should put `self.j_len` between ticks in the documentation"
-rayon/1.5.0/src/iter/interleave.rs:199:23 clippy::doc_markdown "you should put `self.i_len` between ticks in the documentation"
-rayon/1.5.0/src/iter/interleave.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/interleave.rs:200:23 clippy::doc_markdown "you should put `self.j_len` between ticks in the documentation"
-rayon/1.5.0/src/iter/interleave.rs:249:41 clippy::doc_markdown "you should put `DoubleEndedIterator` between ticks in the documentation"
-rayon/1.5.0/src/iter/interleave.rs:250:5 clippy::doc_markdown "you should put `ExactSizeIterator` between ticks in the documentation"
-rayon/1.5.0/src/iter/interleave.rs:263:33 clippy::doc_markdown "you should put `InterleaveSeq` between ticks in the documentation"
-rayon/1.5.0/src/iter/interleave.rs:280:17 clippy::match_wildcard_for_single_variants "wildcard match will miss any future added variants"
-rayon/1.5.0/src/iter/interleave.rs:285:17 clippy::match_wildcard_for_single_variants "wildcard match will miss any future added variants"
-rayon/1.5.0/src/iter/interleave.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/interleave.rs:313:9 clippy::comparison_chain "`if` chain can be rewritten with `match`"
-rayon/1.5.0/src/iter/interleave.rs:82:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/interleave.rs:90:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/interleave_shortest.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/intersperse.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/intersperse.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/intersperse.rs:90:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/intersperse.rs:96:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/len.rs:12:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-rayon/1.5.0/src/iter/len.rs:146:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-rayon/1.5.0/src/iter/len.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/len.rs:200:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/len.rs:205:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/len.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/len.rs:66:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/len.rs:71:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/map.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/map.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/map.rs:84:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/map.rs:89:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/map_with.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/map_with.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/map_with.rs:419:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/map_with.rs:425:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/map_with.rs:90:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/map_with.rs:96:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/mod.rs:1874:24 clippy::trivially_copy_pass_by_ref "this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
-rayon/1.5.0/src/iter/mod.rs:2171:1 clippy::len_without_is_empty "trait `IndexedParallelIterator` has a `len` method but no (possibly inherited) `is_empty` method"
-rayon/1.5.0/src/iter/mod.rs:2371:26 clippy::trivially_copy_pass_by_ref "this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
-rayon/1.5.0/src/iter/mod.rs:2411:26 clippy::trivially_copy_pass_by_ref "this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
-rayon/1.5.0/src/iter/mod.rs:82:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/multizip.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/multizip.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/noop.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/once.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/once.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/panic_fuse.rs:102:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/panic_fuse.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/panic_fuse.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/panic_fuse.rs:98:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/par_bridge.rs:136:28 clippy::redundant_else "redundant else block"
-rayon/1.5.0/src/iter/par_bridge.rs:163:28 clippy::redundant_else "redundant else block"
-rayon/1.5.0/src/iter/plumbing/mod.rs:216:58 clippy::doc_markdown "you should put `find_first` between ticks in the documentation"
-rayon/1.5.0/src/iter/plumbing/mod.rs:359:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/plumbing/mod.rs:364:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/plumbing/mod.rs:399:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/plumbing/mod.rs:53:19 clippy::doc_markdown "you should put `DoubleEndedIterator` between ticks in the documentation"
-rayon/1.5.0/src/iter/plumbing/mod.rs:53:43 clippy::doc_markdown "you should put `ExactSizeIterator` between ticks in the documentation"
-rayon/1.5.0/src/iter/plumbing/mod.rs:54:31 clippy::doc_markdown "you should put `IntoIterator` between ticks in the documentation"
-rayon/1.5.0/src/iter/plumbing/mod.rs:55:5 clippy::doc_markdown "you should put `IntoIterator` between ticks in the documentation"
-rayon/1.5.0/src/iter/positions.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/positions.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/product.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/reduce.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/repeat.rs:103:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-rayon/1.5.0/src/iter/repeat.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/repeat.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/rev.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/rev.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/rev.rs:63:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/rev.rs:68:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/skip.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/skip.rs:3:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/skip.rs:68:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/skip.rs:73:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/splitter.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/splitter.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/step_by.rs:4:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/step_by.rs:5:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/step_by.rs:73:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/step_by.rs:79:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/sum.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/take.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/take.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/take.rs:67:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/take.rs:72:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/try_fold.rs:190:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-rayon/1.5.0/src/iter/try_fold.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/try_fold.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/try_reduce.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/try_reduce_with.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/unzip.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/unzip.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/update.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/update.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/update.rs:82:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/update.rs:87:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/while_some.rs:130:22 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-rayon/1.5.0/src/iter/while_some.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/while_some.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/zip.rs:102:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/zip.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/zip.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/zip.rs:74:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/zip.rs:79:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/zip.rs:97:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/iter/zip_eq.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/iter/zip_eq.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/option.rs:8:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/option.rs:9:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/par_either.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/par_either.rs:3:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/private.rs:9:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-rayon/1.5.0/src/range.rs:19:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/range.rs:20:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/range_inclusive.rs:194:9 clippy::range_plus_one "an inclusive range would be more readable"
-rayon/1.5.0/src/range_inclusive.rs:194:9 clippy::range_plus_one "an inclusive range would be more readable"
-rayon/1.5.0/src/range_inclusive.rs:19:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/range_inclusive.rs:209:9 clippy::range_plus_one "an inclusive range would be more readable"
-rayon/1.5.0/src/range_inclusive.rs:209:9 clippy::range_plus_one "an inclusive range would be more readable"
-rayon/1.5.0/src/range_inclusive.rs:20:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/range_inclusive.rs:231:9 clippy::range_plus_one "an inclusive range would be more readable"
-rayon/1.5.0/src/range_inclusive.rs:231:9 clippy::range_plus_one "an inclusive range would be more readable"
-rayon/1.5.0/src/result.rs:8:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/result.rs:9:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/slice/mergesort.rs:102:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/slice/mergesort.rs:109:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/slice/mergesort.rs:114:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/slice/mergesort.rs:211:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/slice/mergesort.rs:217:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/slice/mergesort.rs:251:5 clippy::doc_markdown "you should put `TimSort` between ticks in the documentation"
-rayon/1.5.0/src/slice/mergesort.rs:252:5 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
-rayon/1.5.0/src/slice/mergesort.rs:286:59 clippy::doc_markdown "you should put `TimSort` between ticks in the documentation"
-rayon/1.5.0/src/slice/mergesort.rs:333:24 clippy::redundant_else "redundant else block"
-rayon/1.5.0/src/slice/mergesort.rs:513:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/slice/mergesort.rs:521:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/slice/mergesort.rs:7:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/slice/mergesort.rs:98:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/slice/mod.rs:15:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/slice/mod.rs:16:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/slice/mod.rs:17:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/slice/mod.rs:25:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-rayon/1.5.0/src/slice/mod.rs:657:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-rayon/1.5.0/src/slice/mod.rs:971:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-rayon/1.5.0/src/slice/quicksort.rs:230:36 clippy::doc_markdown "you should put `BlockQuicksort` between ticks in the documentation"
-rayon/1.5.0/src/slice/quicksort.rs:233:1 clippy::too_many_lines "this function has too many lines (117/100)"
-rayon/1.5.0/src/slice/quicksort.rs:258:26 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-rayon/1.5.0/src/slice/quicksort.rs:265:26 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-rayon/1.5.0/src/slice/quicksort.rs:268:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-rayon/1.5.0/src/slice/quicksort.rs:308:30 clippy::cast_possible_truncation "casting `usize` to `u8` may truncate the value"
-rayon/1.5.0/src/slice/quicksort.rs:325:30 clippy::cast_possible_truncation "casting `usize` to `u8` may truncate the value"
-rayon/1.5.0/src/slice/quicksort.rs:393:36 clippy::cast_possible_wrap "casting `u8` to `isize` may wrap around the value on targets with 32-bit wide pointers"
-rayon/1.5.0/src/slice/quicksort.rs:405:40 clippy::cast_possible_wrap "casting `u8` to `isize` may wrap around the value on targets with 32-bit wide pointers"
-rayon/1.5.0/src/slice/quicksort.rs:430:14 clippy::shadow_unrelated "`pivot` is being shadowed"
-rayon/1.5.0/src/slice/quicksort.rs:439:13 clippy::shadow_unrelated "`pivot` is being shadowed"
-rayon/1.5.0/src/slice/quicksort.rs:482:10 clippy::shadow_unrelated "`pivot` is being shadowed"
-rayon/1.5.0/src/slice/quicksort.rs:491:9 clippy::shadow_unrelated "`pivot` is being shadowed"
-rayon/1.5.0/src/slice/quicksort.rs:534:26 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
-rayon/1.5.0/src/slice/quicksort.rs:545:17 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
-rayon/1.5.0/src/slice/quicksort.rs:588:17 clippy::identity_op "the operation is ineffective. Consider reducing it to `len / 4`"
-rayon/1.5.0/src/slice/quicksort.rs:716:14 clippy::shadow_unrelated "`pivot` is being shadowed"
-rayon/1.5.0/src/split_producer.rs:56:16 clippy::option_if_let_else "use Option::map_or_else instead of an if let/else"
-rayon/1.5.0/src/split_producer.rs:92:9 clippy::option_if_let_else "use Option::map_or instead of an if let/else"
-rayon/1.5.0/src/str.rs:16:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/str.rs:17:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/str.rs:18:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/str.rs:25:5 clippy::cast_possible_wrap "casting `u8` to `i8` may wrap around the value"
-rayon/1.5.0/src/str.rs:715:9 clippy::manual_strip "stripping a suffix manually"
-rayon/1.5.0/src/string.rs:5:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/vec.rs:137:12 clippy::len_zero "length comparison to zero"
-rayon/1.5.0/src/vec.rs:8:5 clippy::wildcard_imports "usage of wildcard import"
-rayon/1.5.0/src/vec.rs:9:5 clippy::wildcard_imports "usage of wildcard import"
-regex/1.3.2/src/backtrack.rs:100:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/backtrack.rs:133:17 clippy::same_item_push "it looks like the same item is being pushed into this Vec"
-regex/1.3.2/src/backtrack.rs:145:20 clippy::if_not_else "unnecessary boolean `not` operation"
-regex/1.3.2/src/backtrack.rs:199:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
-regex/1.3.2/src/backtrack.rs:223:29 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/backtrack.rs:230:66 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/backtrack.rs:284:21 clippy::cast_lossless "casting `u32` to `u64` may become silently lossy if you later change the type"
-regex/1.3.2/src/backtrack.rs:287:5 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
-regex/1.3.2/src/backtrack.rs:97:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/backtrack.rs:98:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/backtrack.rs:99:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/compile.rs:1005:32 clippy::unreadable_literal "long literal lacking separators"
-regex/1.3.2/src/compile.rs:1006:21 clippy::unreadable_literal "long literal lacking separators"
-regex/1.3.2/src/compile.rs:1008:18 clippy::cast_lossless "casting `u8` to `u64` may become silently lossy if you later change the type"
-regex/1.3.2/src/compile.rs:1009:18 clippy::cast_lossless "casting `u8` to `u64` may become silently lossy if you later change the type"
-regex/1.3.2/src/compile.rs:1010:9 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
-regex/1.3.2/src/compile.rs:102:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/compile.rs:1037:37 clippy::cast_possible_truncation "casting `u16` to `u8` may truncate the value"
-regex/1.3.2/src/compile.rs:1037:55 clippy::cast_possible_truncation "casting `u16` to `u8` may truncate the value"
-regex/1.3.2/src/compile.rs:1040:28 clippy::cast_possible_truncation "casting `u16` to `u8` may truncate the value"
-regex/1.3.2/src/compile.rs:1040:38 clippy::cast_possible_truncation "casting `u16` to `u8` may truncate the value"
-regex/1.3.2/src/compile.rs:1051:25 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-regex/1.3.2/src/compile.rs:1071:8 clippy::cast_lossless "casting `u32` to `u64` may become silently lossy if you later change the type"
-regex/1.3.2/src/compile.rs:112:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-regex/1.3.2/src/compile.rs:154:30 clippy::redundant_closure_for_method_calls "redundant closure found"
-regex/1.3.2/src/compile.rs:156:30 clippy::redundant_closure_for_method_calls "redundant closure found"
-regex/1.3.2/src/compile.rs:185:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
-regex/1.3.2/src/compile.rs:187:40 clippy::redundant_closure_for_method_calls "redundant closure found"
-regex/1.3.2/src/compile.rs:201:53 clippy::doc_markdown "you should put `MaybeInsts` between ticks in the documentation"
-regex/1.3.2/src/compile.rs:241:63 clippy::doc_markdown "you should put `c_concat` between ticks in the documentation"
-regex/1.3.2/src/compile.rs:245:5 clippy::too_many_lines "this function has too many lines (111/100)"
-regex/1.3.2/src/compile.rs:247:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
-regex/1.3.2/src/compile.rs:373:24 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/compile.rs:373:36 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/compile.rs:378:12 clippy::if_not_else "unnecessary boolean `not` operation"
-regex/1.3.2/src/compile.rs:400:37 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/compile.rs:407:51 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/compile.rs:409:24 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/compile.rs:417:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
-regex/1.3.2/src/compile.rs:42:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/compile.rs:42:5 clippy::new_without_default "you should consider adding a `Default` implementation for `compile::Compiler`"
-regex/1.3.2/src/compile.rs:444:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
-regex/1.3.2/src/compile.rs:445:57 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/compile.rs:446:20 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/compile.rs:466:20 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/compile.rs:466:32 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/compile.rs:519:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
-regex/1.3.2/src/compile.rs:55:57 clippy::doc_markdown "you should put `size_limit` between ticks in the documentation"
-regex/1.3.2/src/compile.rs:58:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/compile.rs:748:41 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/compile.rs:74:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/compile.rs:751:54 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/compile.rs:765:41 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/compile.rs:765:55 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/compile.rs:825:39 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/compile.rs:825:51 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/compile.rs:828:49 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/compile.rs:828:61 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/compile.rs:830:59 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/compile.rs:830:71 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/compile.rs:832:43 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/compile.rs:835:41 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/compile.rs:835:53 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/compile.rs:835:67 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/compile.rs:83:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/compile.rs:896:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
-regex/1.3.2/src/compile.rs:905:17 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/compile.rs:953:17 clippy::doc_markdown "you should put `HashMap` between ticks in the documentation"
-regex/1.3.2/src/compile.rs:95:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/compile.rs:980:26 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-regex/1.3.2/src/compile.rs:994:44 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/compile.rs:994:54 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/dfa.rs:1007:17 clippy::similar_names "binding's name is too similar to existing binding"
-regex/1.3.2/src/dfa.rs:1010:22 clippy::similar_names "binding's name is too similar to existing binding"
-regex/1.3.2/src/dfa.rs:1059:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
-regex/1.3.2/src/dfa.rs:1060:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
-regex/1.3.2/src/dfa.rs:1084:38 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
-regex/1.3.2/src/dfa.rs:1087:38 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
-regex/1.3.2/src/dfa.rs:1090:38 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
-regex/1.3.2/src/dfa.rs:1093:38 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
-regex/1.3.2/src/dfa.rs:1096:38 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
-regex/1.3.2/src/dfa.rs:1101:38 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
-regex/1.3.2/src/dfa.rs:1104:38 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
-regex/1.3.2/src/dfa.rs:1107:38 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
-regex/1.3.2/src/dfa.rs:1117:30 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
-regex/1.3.2/src/dfa.rs:1120:47 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
-regex/1.3.2/src/dfa.rs:1121:30 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
-regex/1.3.2/src/dfa.rs:1129:13 clippy::doc_markdown "you should put `is_match` between ticks in the documentation"
-regex/1.3.2/src/dfa.rs:1134:13 clippy::doc_markdown "you should put `is_match` between ticks in the documentation"
-regex/1.3.2/src/dfa.rs:1185:68 clippy::doc_markdown "you should put `is_match` between ticks in the documentation"
-regex/1.3.2/src/dfa.rs:1193:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
-regex/1.3.2/src/dfa.rs:1244:50 clippy::doc_markdown "you should put `current_state` between ticks in the documentation"
-regex/1.3.2/src/dfa.rs:1338:58 clippy::doc_markdown "you should put `STATE_DEAD` between ticks in the documentation"
-regex/1.3.2/src/dfa.rs:1339:9 clippy::doc_markdown "you should put `STATE_UNKNOWN` between ticks in the documentation"
-regex/1.3.2/src/dfa.rs:1366:25 clippy::doc_markdown "you should put `STATE_DEAD` between ticks in the documentation"
-regex/1.3.2/src/dfa.rs:1366:46 clippy::doc_markdown "you should put `STATE_UNKNOWN` between ticks in the documentation"
-regex/1.3.2/src/dfa.rs:1367:41 clippy::inline_always "you have declared `#[inline(always)]` on `start_state`. This is usually a bad idea"
-regex/1.3.2/src/dfa.rs:1380:14 clippy::identity_op "the operation is ineffective. Consider reducing it to `(empty_flags.start as u8)`"
-regex/1.3.2/src/dfa.rs:1388:15 clippy::match_on_vec_items "indexing into a vector may panic"
-regex/1.3.2/src/dfa.rs:1412:20 clippy::unused_self "unused `self` argument"
-regex/1.3.2/src/dfa.rs:1438:9 clippy::unused_self "unused `self` argument"
-regex/1.3.2/src/dfa.rs:1472:9 clippy::doc_markdown "you should put `StatePtr` between ticks in the documentation"
-regex/1.3.2/src/dfa.rs:1490:54 clippy::cast_possible_truncation "casting `i32` to `u8` may truncate the value"
-regex/1.3.2/src/dfa.rs:1490:54 clippy::cast_sign_loss "casting `i32` to `u8` may lose the sign of the value"
-regex/1.3.2/src/dfa.rs:1521:20 clippy::doc_markdown "you should put `num_byte_classes` between ticks in the documentation"
-regex/1.3.2/src/dfa.rs:1529:41 clippy::inline_always "you have declared `#[inline(always)]` on `byte_class`. This is usually a bad idea"
-regex/1.3.2/src/dfa.rs:1537:14 clippy::doc_markdown "you should put `byte_class` between ticks in the documentation"
-regex/1.3.2/src/dfa.rs:1538:41 clippy::inline_always "you have declared `#[inline(always)]` on `u8_class`. This is usually a bad idea"
-regex/1.3.2/src/dfa.rs:1562:18 clippy::doc_markdown "you should put `STATE_START` between ticks in the documentation"
-regex/1.3.2/src/dfa.rs:1614:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/dfa.rs:1651:38 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/dfa.rs:1700:17 clippy::trivially_copy_pass_by_ref "this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
-regex/1.3.2/src/dfa.rs:1701:18 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
-regex/1.3.2/src/dfa.rs:1705:19 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
-regex/1.3.2/src/dfa.rs:1708:16 clippy::trivially_copy_pass_by_ref "this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
-regex/1.3.2/src/dfa.rs:1709:18 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
-regex/1.3.2/src/dfa.rs:1713:19 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
-regex/1.3.2/src/dfa.rs:1716:18 clippy::trivially_copy_pass_by_ref "this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
-regex/1.3.2/src/dfa.rs:1717:18 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
-regex/1.3.2/src/dfa.rs:1721:19 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
-regex/1.3.2/src/dfa.rs:1727:14 clippy::cast_lossless "casting `u8` to `u16` may become silently lossy if you later change the type"
-regex/1.3.2/src/dfa.rs:1732:15 clippy::trivially_copy_pass_by_ref "this argument (2 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
-regex/1.3.2/src/dfa.rs:1736:22 clippy::trivially_copy_pass_by_ref "this argument (2 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
-regex/1.3.2/src/dfa.rs:1741:9 clippy::match_like_matches_macro "match expression looks like `matches!` macro"
-regex/1.3.2/src/dfa.rs:1747:16 clippy::trivially_copy_pass_by_ref "this argument (2 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
-regex/1.3.2/src/dfa.rs:1751:18 clippy::cast_possible_truncation "casting `u16` to `u8` may truncate the value"
-regex/1.3.2/src/dfa.rs:1815:38 clippy::cast_possible_truncation "casting `usize` to `u8` may truncate the value"
-regex/1.3.2/src/dfa.rs:1821:21 clippy::cast_lossless "casting `u32` to `u64` may become silently lossy if you later change the type"
-regex/1.3.2/src/dfa.rs:1824:5 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
-regex/1.3.2/src/dfa.rs:1848:5 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
-regex/1.3.2/src/dfa.rs:1850:18 clippy::cast_sign_loss "casting `i32` to `u32` may lose the sign of the value"
-regex/1.3.2/src/dfa.rs:1857:5 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
-regex/1.3.2/src/dfa.rs:1860:17 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
-regex/1.3.2/src/dfa.rs:1867:5 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
-regex/1.3.2/src/dfa.rs:1870:19 clippy::cast_possible_truncation "casting `u32` to `u8` may truncate the value"
-regex/1.3.2/src/dfa.rs:1873:15 clippy::cast_possible_truncation "casting `u32` to `u8` may truncate the value"
-regex/1.3.2/src/dfa.rs:1876:5 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
-regex/1.3.2/src/dfa.rs:1882:26 clippy::cast_lossless "casting `u8` to `u32` may become silently lossy if you later change the type"
-regex/1.3.2/src/dfa.rs:1884:15 clippy::cast_lossless "casting `u8` to `u32` may become silently lossy if you later change the type"
-regex/1.3.2/src/dfa.rs:277:17 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
-regex/1.3.2/src/dfa.rs:277:31 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
-regex/1.3.2/src/dfa.rs:295:20 clippy::cast_possible_truncation "casting `usize` to `i32` may truncate the value on targets with 64-bit wide pointers"
-regex/1.3.2/src/dfa.rs:295:20 clippy::cast_possible_wrap "casting `usize` to `i32` may wrap around the value on targets with 32-bit wide pointers"
-regex/1.3.2/src/dfa.rs:299:21 clippy::cast_sign_loss "casting `i32` to `usize` may lose the sign of the value"
-regex/1.3.2/src/dfa.rs:34:46 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
-regex/1.3.2/src/dfa.rs:398:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
-regex/1.3.2/src/dfa.rs:446:41 clippy::inline_always "you have declared `#[inline(always)]` on `forward`. This is usually a bad idea"
-regex/1.3.2/src/dfa.rs:457:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/dfa.rs:459:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/dfa.rs:460:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/dfa.rs:476:41 clippy::inline_always "you have declared `#[inline(always)]` on `reverse`. This is usually a bad idea"
-regex/1.3.2/src/dfa.rs:487:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/dfa.rs:489:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/dfa.rs:490:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/dfa.rs:506:41 clippy::inline_always "you have declared `#[inline(always)]` on `forward_many`. This is usually a bad idea"
-regex/1.3.2/src/dfa.rs:518:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/dfa.rs:520:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/dfa.rs:554:41 clippy::inline_always "you have declared `#[inline(always)]` on `exec_at`. This is usually a bad idea"
-regex/1.3.2/src/dfa.rs:555:5 clippy::too_many_lines "this function has too many lines (101/100)"
-regex/1.3.2/src/dfa.rs:58:9 clippy::enum_glob_use "usage of wildcard import for enum variants"
-regex/1.3.2/src/dfa.rs:667:21 clippy::similar_names "binding's name is too similar to existing binding"
-regex/1.3.2/src/dfa.rs:747:41 clippy::inline_always "you have declared `#[inline(always)]` on `exec_at_reverse`. This is usually a bad idea"
-regex/1.3.2/src/dfa.rs:795:21 clippy::similar_names "binding's name is too similar to existing binding"
-regex/1.3.2/src/dfa.rs:848:9 clippy::doc_markdown "you should put `next_si` between ticks in the documentation"
-regex/1.3.2/src/dfa.rs:852:41 clippy::inline_always "you have declared `#[inline(always)]` on `next_si`. This is usually a bad idea"
-regex/1.3.2/src/dfa.rs:885:12 clippy::doc_markdown "you should put `STATE_DEAD` between ticks in the documentation"
-regex/1.3.2/src/dfa.rs:889:9 clippy::doc_markdown "you should put `STATE_UNKNOWN` between ticks in the documentation"
-regex/1.3.2/src/dfa.rs:897:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
-regex/1.3.2/src/dfa.rs:979:29 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
-regex/1.3.2/src/error.rs:6:1 clippy::manual_non_exhaustive "this seems like a manual implementation of the non-exhaustive pattern"
-regex/1.3.2/src/exec.rs:1000:14 clippy::doc_markdown "you should put `captures_nfa` between ticks in the documentation"
-regex/1.3.2/src/exec.rs:100:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-regex/1.3.2/src/exec.rs:1028:5 clippy::too_many_arguments "this function has too many arguments (9/7)"
-regex/1.3.2/src/exec.rs:1039:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
-regex/1.3.2/src/exec.rs:1144:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
-regex/1.3.2/src/exec.rs:1179:26 clippy::match_same_arms "this `match` has identical arm bodies"
-regex/1.3.2/src/exec.rs:122:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/exec.rs:1250:41 clippy::inline_always "you have declared `#[inline(always)]` on `searcher`. This is usually a bad idea"
-regex/1.3.2/src/exec.rs:1260:41 clippy::inline_always "you have declared `#[inline(always)]` on `searcher_str`. This is usually a bad idea"
-regex/1.3.2/src/exec.rs:1270:17 clippy::doc_markdown "you should put `RegexSet` between ticks in the documentation"
-regex/1.3.2/src/exec.rs:1280:17 clippy::doc_markdown "you should put `RegexSet` between ticks in the documentation"
-regex/1.3.2/src/exec.rs:137:9 clippy::field_reassign_with_default "field assignment outside of initializer for an instance created with Default::default()"
-regex/1.3.2/src/exec.rs:142:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/exec.rs:1493:5 clippy::upper_case_acronyms "name `PikeVM` contains a capitalized acronym"
-regex/1.3.2/src/exec.rs:158:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/exec.rs:168:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/exec.rs:181:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/exec.rs:195:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/exec.rs:204:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/exec.rs:210:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/exec.rs:245:62 clippy::if_same_then_else "this `if` has identical blocks"
-regex/1.3.2/src/exec.rs:251:21 clippy::if_not_else "unnecessary boolean `not` operation"
-regex/1.3.2/src/exec.rs:262:60 clippy::if_same_then_else "this `if` has identical blocks"
-regex/1.3.2/src/exec.rs:268:21 clippy::if_not_else "unnecessary boolean `not` operation"
-regex/1.3.2/src/exec.rs:278:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/exec.rs:281:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/exec.rs:286:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-regex/1.3.2/src/exec.rs:300:30 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/exec.rs:308:17 clippy::similar_names "binding's name is too similar to existing binding"
-regex/1.3.2/src/exec.rs:329:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/exec.rs:330:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/exec.rs:331:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/exec.rs:334:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/exec.rs:340:19 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/exec.rs:344:27 clippy::unused_self "unused `self` argument"
-regex/1.3.2/src/exec.rs:383:41 clippy::inline_always "you have declared `#[inline(always)]` on `shortest_match_at`. This is usually a bad idea"
-regex/1.3.2/src/exec.rs:388:41 clippy::inline_always "you have declared `#[inline(always)]` on `is_match_at`. This is usually a bad idea"
-regex/1.3.2/src/exec.rs:393:41 clippy::inline_always "you have declared `#[inline(always)]` on `find_at`. This is usually a bad idea"
-regex/1.3.2/src/exec.rs:398:41 clippy::inline_always "you have declared `#[inline(always)]` on `captures_read_at`. This is usually a bad idea"
-regex/1.3.2/src/exec.rs:425:41 clippy::inline_always "you have declared `#[inline(always)]` on `shortest_match_at`. This is usually a bad idea"
-regex/1.3.2/src/exec.rs:44:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-regex/1.3.2/src/exec.rs:473:9 clippy::doc_markdown "you should put `shortest_match(...).is_some` between ticks in the documentation"
-regex/1.3.2/src/exec.rs:474:41 clippy::inline_always "you have declared `#[inline(always)]` on `is_match_at`. This is usually a bad idea"
-regex/1.3.2/src/exec.rs:524:41 clippy::inline_always "you have declared `#[inline(always)]` on `find_at`. This is usually a bad idea"
-regex/1.3.2/src/exec.rs:52:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-regex/1.3.2/src/exec.rs:686:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
-regex/1.3.2/src/exec.rs:727:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
-regex/1.3.2/src/exec.rs:767:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
-regex/1.3.2/src/exec.rs:783:41 clippy::inline_always "you have declared `#[inline(always)]` on `shortest_dfa`. This is usually a bad idea"
-regex/1.3.2/src/exec.rs:791:41 clippy::inline_always "you have declared `#[inline(always)]` on `shortest_dfa_reverse_suffix`. This is usually a bad idea"
-regex/1.3.2/src/exec.rs:823:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
-regex/1.3.2/src/exec.rs:868:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
-regex/1.3.2/src/exec.rs:897:31 clippy::doc_markdown "you should put `shortest_nfa(...).is_some` between ticks in the documentation"
-regex/1.3.2/src/exec.rs:899:9 clippy::doc_markdown "you should put `shortest_nfa` between ticks in the documentation"
-regex/1.3.2/src/exec.rs:905:14 clippy::doc_markdown "you should put `match_nfa` between ticks in the documentation"
-regex/1.3.2/src/exec.rs:930:14 clippy::doc_markdown "you should put `shortest_nfa` between ticks in the documentation"
-regex/1.3.2/src/exec.rs:981:14 clippy::doc_markdown "you should put `find_nfa` between ticks in the documentation"
-regex/1.3.2/src/expand.rs:170:27 clippy::trivially_copy_pass_by_ref "this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
-regex/1.3.2/src/expand.rs:171:5 clippy::match_like_matches_macro "match expression looks like `matches!` macro"
-regex/1.3.2/src/expand.rs:22:13 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
-regex/1.3.2/src/expand.rs:27:23 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-regex/1.3.2/src/expand.rs:30:17 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
-regex/1.3.2/src/expand.rs:38:30 clippy::map_unwrap_or "called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead"
-regex/1.3.2/src/expand.rs:42:21 clippy::map_unwrap_or "called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead"
-regex/1.3.2/src/expand.rs:50:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-regex/1.3.2/src/expand.rs:69:23 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-regex/1.3.2/src/expand.rs:80:28 clippy::map_unwrap_or "called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead"
-regex/1.3.2/src/expand.rs:84:21 clippy::map_unwrap_or "called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead"
-regex/1.3.2/src/expand.rs:8:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-regex/1.3.2/src/input.rs:142:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-regex/1.3.2/src/input.rs:146:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/input.rs:15:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-regex/1.3.2/src/input.rs:165:31 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/input.rs:178:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
-regex/1.3.2/src/input.rs:228:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-regex/1.3.2/src/input.rs:236:21 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/input.rs:236:33 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/input.rs:24:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/input.rs:271:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
-regex/1.3.2/src/input.rs:29:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/input.rs:362:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/input.rs:370:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/input.rs:371:42 clippy::redundant_closure_for_method_calls "redundant closure found"
-regex/1.3.2/src/input.rs:37:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/input.rs:388:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/input.rs:42:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/input.rs:47:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/input.rs:53:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/input.rs:58:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/input.rs:63:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/lib.rs:1:null clippy::cargo_common_metadata "package `regex` is missing `package.keywords` metadata"
-regex/1.3.2/src/literal/imp.rs:101:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/literal/imp.rs:114:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/literal/imp.rs:127:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/literal/imp.rs:139:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/literal/imp.rs:144:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/literal/imp.rs:149:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/literal/imp.rs:154:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/literal/imp.rs:155:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
-regex/1.3.2/src/literal/imp.rs:160:30 clippy::match_same_arms "this `match` has identical arm bodies"
-regex/1.3.2/src/literal/imp.rs:167:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/literal/imp.rs:168:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
-regex/1.3.2/src/literal/imp.rs:211:20 clippy::redundant_else "redundant else block"
-regex/1.3.2/src/literal/imp.rs:239:5 clippy::upper_case_acronyms "name `AC` contains a capitalized acronym"
-regex/1.3.2/src/literal/imp.rs:276:50 clippy::match_same_arms "this `match` has identical arm bodies"
-regex/1.3.2/src/literal/imp.rs:342:41 clippy::inline_always "you have declared `#[inline(always)]` on `find`. This is usually a bad idea"
-regex/1.3.2/src/literal/imp.rs:34:5 clippy::upper_case_acronyms "name `AC` contains a capitalized acronym"
-regex/1.3.2/src/literal/imp.rs:435:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/literal/imp.rs:436:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/literal/imp.rs:437:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/literal/imp.rs:438:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/literal/imp.rs:439:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/literal/imp.rs:440:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/literal/imp.rs:455:41 clippy::inline_always "you have declared `#[inline(always)]` on `find`. This is usually a bad idea"
-regex/1.3.2/src/literal/imp.rs:46:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/literal/imp.rs:481:41 clippy::inline_always "you have declared `#[inline(always)]` on `is_suffix`. This is usually a bad idea"
-regex/1.3.2/src/literal/imp.rs:51:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/literal/imp.rs:579:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/literal/imp.rs:57:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/literal/imp.rs:580:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/literal/imp.rs:583:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/literal/imp.rs:602:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-regex/1.3.2/src/literal/imp.rs:622:24 clippy::redundant_else "redundant else block"
-regex/1.3.2/src/literal/imp.rs:62:18 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
-regex/1.3.2/src/literal/imp.rs:637:24 clippy::redundant_else "redundant else block"
-regex/1.3.2/src/literal/imp.rs:648:9 clippy::needless_return "unneeded `return` statement"
-regex/1.3.2/src/literal/imp.rs:651:44 clippy::doc_markdown "you should put `BoyerMooreSearch` between ticks in the documentation"
-regex/1.3.2/src/literal/imp.rs:65:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/literal/imp.rs:68:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/literal/imp.rs:783:32 clippy::redundant_else "redundant else block"
-regex/1.3.2/src/literal/imp.rs:786:42 clippy::manual_saturating_arithmetic "manual saturating arithmetic"
-regex/1.3.2/src/literal/imp.rs:78:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/literal/imp.rs:84:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/literal/imp.rs:850:20 clippy::unreadable_literal "long literal lacking separators"
-regex/1.3.2/src/literal/imp.rs:85:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
-regex/1.3.2/src/pikevm.rs:103:15 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/pikevm.rs:103:52 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/pikevm.rs:114:5 clippy::too_many_arguments "this function has too many arguments (8/7)"
-regex/1.3.2/src/pikevm.rs:117:13 clippy::similar_names "binding's name is too similar to existing binding"
-regex/1.3.2/src/pikevm.rs:124:17 clippy::similar_names "binding's name is too similar to existing binding"
-regex/1.3.2/src/pikevm.rs:220:9 clippy::doc_markdown "you should put `thread_caps` between ticks in the documentation"
-regex/1.3.2/src/pikevm.rs:222:16 clippy::doc_markdown "you should put `at_next` between ticks in the documentation"
-regex/1.3.2/src/pikevm.rs:223:9 clippy::doc_markdown "you should put `at_next` between ticks in the documentation"
-regex/1.3.2/src/pikevm.rs:224:5 clippy::too_many_arguments "this function has too many arguments (8/7)"
-regex/1.3.2/src/pikevm.rs:234:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
-regex/1.3.2/src/pikevm.rs:303:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
-regex/1.3.2/src/pikevm.rs:331:29 clippy::mut_mut "this expression mutably borrows a mutable reference. Consider reborrowing"
-regex/1.3.2/src/pikevm.rs:70:5 clippy::upper_case_acronyms "name `IP` contains a capitalized acronym"
-regex/1.3.2/src/pikevm.rs:88:5 clippy::too_many_arguments "this function has too many arguments (8/7)"
-regex/1.3.2/src/prog.rs:102:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/prog.rs:113:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/prog.rs:120:9 clippy::match_like_matches_macro "match expression looks like `matches!` macro"
-regex/1.3.2/src/prog.rs:128:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/prog.rs:134:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/prog.rs:141:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/prog.rs:147:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/prog.rs:164:41 clippy::inline_always "you have declared `#[inline(always)]` on `deref`. This is usually a bad idea"
-regex/1.3.2/src/prog.rs:172:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
-regex/1.3.2/src/prog.rs:18:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
-regex/1.3.2/src/prog.rs:236:13 clippy::write_with_newline "using `write!()` with a format string that ends in a single newline"
-regex/1.3.2/src/prog.rs:300:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/prog.rs:301:9 clippy::match_like_matches_macro "match expression looks like `matches!` macro"
-regex/1.3.2/src/prog.rs:382:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/prog.rs:409:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/prog.rs:80:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/prog.rs:80:5 clippy::new_without_default "you should consider adding a `Default` implementation for `prog::Program`"
-regex/1.3.2/src/re_builder.rs:267:17 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-regex/1.3.2/src/re_builder.rs:267:17 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-regex/1.3.2/src/re_builder.rs:4:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
-regex/1.3.2/src/re_builder.rs:57:17 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/re_builder.rs:57:17 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/re_builder.rs:68:17 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-regex/1.3.2/src/re_builder.rs:68:17 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-regex/1.3.2/src/re_bytes.rs:1017:9 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
-regex/1.3.2/src/re_bytes.rs:1039:9 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
-regex/1.3.2/src/re_bytes.rs:1093:5 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
-regex/1.3.2/src/re_bytes.rs:1118:5 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
-regex/1.3.2/src/re_bytes.rs:1133:5 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
-regex/1.3.2/src/re_bytes.rs:118:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-regex/1.3.2/src/re_bytes.rs:256:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/re_bytes.rs:29:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/re_bytes.rs:35:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/re_bytes.rs:42:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/re_bytes.rs:48:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/re_bytes.rs:558:29 clippy::doc_markdown "you should put `shortest_match` between ticks in the documentation"
-regex/1.3.2/src/re_bytes.rs:55:33 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/re_bytes.rs:55:47 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/re_bytes.rs:572:29 clippy::doc_markdown "you should put `is_match` between ticks in the documentation"
-regex/1.3.2/src/re_bytes.rs:720:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/re_bytes.rs:817:5 clippy::doc_markdown "you should put `CaptureLocations` between ticks in the documentation"
-regex/1.3.2/src/re_bytes.rs:843:1 clippy::len_without_is_empty "item `re_bytes::CaptureLocations` has a public `len` method but no corresponding `is_empty` method"
-regex/1.3.2/src/re_bytes.rs:849:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/re_bytes.rs:858:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/re_bytes.rs:869:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/re_bytes.rs:891:1 clippy::len_without_is_empty "item `re_bytes::Captures<'t>` has a public `len` method but no corresponding `is_empty` method"
-regex/1.3.2/src/re_bytes.rs:911:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/re_bytes.rs:917:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/re_bytes.rs:926:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/re_bytes.rs:955:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/re_set.rs:179:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/re_set.rs:179:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/re_set.rs:251:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/re_set.rs:251:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/re_set.rs:263:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/re_set.rs:263:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/re_set.rs:268:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/re_set.rs:268:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/re_set.rs:277:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/re_set.rs:277:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/re_set.rs:94:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-regex/1.3.2/src/re_set.rs:94:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-regex/1.3.2/src/re_trait.rs:136:29 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/re_unicode.rs:1019:9 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
-regex/1.3.2/src/re_unicode.rs:1041:9 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
-regex/1.3.2/src/re_unicode.rs:1088:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/re_unicode.rs:1135:5 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
-regex/1.3.2/src/re_unicode.rs:1160:5 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
-regex/1.3.2/src/re_unicode.rs:174:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
-regex/1.3.2/src/re_unicode.rs:21:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
-regex/1.3.2/src/re_unicode.rs:313:13 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/re_unicode.rs:38:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/re_unicode.rs:44:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/re_unicode.rs:51:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/re_unicode.rs:57:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/re_unicode.rs:617:29 clippy::doc_markdown "you should put `shortest_match` between ticks in the documentation"
-regex/1.3.2/src/re_unicode.rs:631:29 clippy::doc_markdown "you should put `is_match` between ticks in the documentation"
-regex/1.3.2/src/re_unicode.rs:64:33 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/re_unicode.rs:64:47 clippy::redundant_field_names "redundant field names in struct initialization"
-regex/1.3.2/src/re_unicode.rs:834:5 clippy::doc_markdown "you should put `CaptureLocations` between ticks in the documentation"
-regex/1.3.2/src/re_unicode.rs:860:1 clippy::len_without_is_empty "item `re_unicode::CaptureLocations` has a public `len` method but no corresponding `is_empty` method"
-regex/1.3.2/src/re_unicode.rs:866:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/re_unicode.rs:875:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/re_unicode.rs:886:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/re_unicode.rs:908:1 clippy::len_without_is_empty "item `re_unicode::Captures<'t>` has a public `len` method but no corresponding `is_empty` method"
-regex/1.3.2/src/re_unicode.rs:928:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/re_unicode.rs:934:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/re_unicode.rs:943:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/re_unicode.rs:972:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
-regex/1.3.2/src/sparse.rs:10:37 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
-regex/1.3.2/src/sparse.rs:15:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-regex/1.3.2/src/utf8.rs:100:16 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
-regex/1.3.2/src/utf8.rs:103:16 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
-regex/1.3.2/src/utf8.rs:106:22 clippy::cast_lossless "casting `u8` to `u32` may become silently lossy if you later change the type"
-regex/1.3.2/src/utf8.rs:107:19 clippy::cast_lossless "casting `u8` to `u32` may become silently lossy if you later change the type"
-regex/1.3.2/src/utf8.rs:108:19 clippy::cast_lossless "casting `u8` to `u32` may become silently lossy if you later change the type"
-regex/1.3.2/src/utf8.rs:109:19 clippy::cast_lossless "casting `u8` to `u32` may become silently lossy if you later change the type"
-regex/1.3.2/src/utf8.rs:111:27 clippy::unreadable_literal "long literal lacking separators"
-regex/1.3.2/src/utf8.rs:121:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-regex/1.3.2/src/utf8.rs:143:24 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
-regex/1.3.2/src/utf8.rs:143:9 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
-regex/1.3.2/src/utf8.rs:23:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-regex/1.3.2/src/utf8.rs:30:20 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
-regex/1.3.2/src/utf8.rs:51:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-regex/1.3.2/src/utf8.rs:58:23 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
-regex/1.3.2/src/utf8.rs:58:9 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
-regex/1.3.2/src/utf8.rs:63:16 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
-regex/1.3.2/src/utf8.rs:66:22 clippy::cast_lossless "casting `u8` to `u32` may become silently lossy if you later change the type"
-regex/1.3.2/src/utf8.rs:66:54 clippy::cast_lossless "casting `u8` to `u32` may become silently lossy if you later change the type"
-regex/1.3.2/src/utf8.rs:77:16 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
-regex/1.3.2/src/utf8.rs:80:16 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
-regex/1.3.2/src/utf8.rs:83:22 clippy::cast_lossless "casting `u8` to `u32` may become silently lossy if you later change the type"
-regex/1.3.2/src/utf8.rs:84:19 clippy::cast_lossless "casting `u8` to `u32` may become silently lossy if you later change the type"
-regex/1.3.2/src/utf8.rs:85:19 clippy::cast_lossless "casting `u8` to `u32` may become silently lossy if you later change the type"
-regex/1.3.2/src/utf8.rs:92:23 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
-regex/1.3.2/src/utf8.rs:92:9 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
-regex/1.3.2/src/utf8.rs:97:16 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
-ripgrep/12.1.1//home/matthias/.rustup/toolchains/nightly-2021-01-15-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/std/src/macros.rs:14:27 clippy::match_same_arms "this `match` has identical arm bodies"
-ripgrep/12.1.1//home/matthias/.rustup/toolchains/nightly-2021-01-15-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/std/src/macros.rs:14:27 clippy::match_same_arms "this `match` has identical arm bodies"
-ripgrep/12.1.1//home/matthias/.rustup/toolchains/nightly-2021-01-15-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/std/src/macros.rs:14:27 clippy::match_same_arms "this `match` has identical arm bodies"
-ripgrep/12.1.1//home/matthias/.rustup/toolchains/nightly-2021-01-15-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/std/src/macros.rs:14:27 clippy::match_same_arms "this `match` has identical arm bodies"
-ripgrep/12.1.1/build.rs:133:19 clippy::option_as_ref_deref "called `.as_ref().map(|x| &**x)` on an Option value. This can be done more directly by calling `githash.as_deref()` instead"
-ripgrep/12.1.1/build.rs:18:18 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-ripgrep/12.1.1/build.rs:225:14 clippy::redundant_closure_for_method_calls "redundant closure found"
-ripgrep/12.1.1/build.rs:92:19 clippy::option_as_ref_deref "called `.as_ref().map(|x| &**x)` on an Option value. This can be done more directly by calling `githash.as_deref()` instead"
-ripgrep/12.1.1/crates/core/app.rs:1408:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-ripgrep/12.1.1/crates/core/app.rs:1408:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-ripgrep/12.1.1/crates/core/app.rs:1409:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-ripgrep/12.1.1/crates/core/app.rs:1409:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-ripgrep/12.1.1/crates/core/app.rs:152:32 clippy::doc_markdown "you should put `clap::Arg` between ticks in the documentation"
-ripgrep/12.1.1/crates/core/app.rs:152:32 clippy::doc_markdown "you should put `clap::Arg` between ticks in the documentation"
-ripgrep/12.1.1/crates/core/app.rs:156:39 clippy::doc_markdown "you should put `clap::Arg` between ticks in the documentation"
-ripgrep/12.1.1/crates/core/app.rs:156:39 clippy::doc_markdown "you should put `clap::Arg` between ticks in the documentation"
-ripgrep/12.1.1/crates/core/app.rs:156:5 clippy::doc_markdown "you should put `RGArg` between ticks in the documentation"
-ripgrep/12.1.1/crates/core/app.rs:156:5 clippy::doc_markdown "you should put `RGArg` between ticks in the documentation"
-ripgrep/12.1.1/crates/core/app.rs:164:12 clippy::upper_case_acronyms "name `RGArg` contains a capitalized acronym"
-ripgrep/12.1.1/crates/core/app.rs:164:12 clippy::upper_case_acronyms "name `RGArg` contains a capitalized acronym"
-ripgrep/12.1.1/crates/core/app.rs:1668:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-ripgrep/12.1.1/crates/core/app.rs:1668:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-ripgrep/12.1.1/crates/core/app.rs:1669:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-ripgrep/12.1.1/crates/core/app.rs:1669:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-ripgrep/12.1.1/crates/core/app.rs:1821:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-ripgrep/12.1.1/crates/core/app.rs:1821:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-ripgrep/12.1.1/crates/core/app.rs:1822:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-ripgrep/12.1.1/crates/core/app.rs:1822:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-ripgrep/12.1.1/crates/core/app.rs:212:10 clippy::upper_case_acronyms "name `RGArgKind` contains a capitalized acronym"
-ripgrep/12.1.1/crates/core/app.rs:212:10 clippy::upper_case_acronyms "name `RGArgKind` contains a capitalized acronym"
-ripgrep/12.1.1/crates/core/app.rs:2999:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-ripgrep/12.1.1/crates/core/app.rs:2999:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-ripgrep/12.1.1/crates/core/app.rs:3000:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-ripgrep/12.1.1/crates/core/app.rs:3000:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
-ripgrep/12.1.1/crates/core/app.rs:367:54 clippy::match_same_arms "this `match` has identical arm bodies"
-ripgrep/12.1.1/crates/core/app.rs:367:54 clippy::match_same_arms "this `match` has identical arm bodies"
-ripgrep/12.1.1/crates/core/app.rs:414:59 clippy::match_same_arms "this `match` has identical arm bodies"
-ripgrep/12.1.1/crates/core/app.rs:414:59 clippy::match_same_arms "this `match` has identical arm bodies"
-ripgrep/12.1.1/crates/core/app.rs:417:57 clippy::match_same_arms "this `match` has identical arm bodies"
-ripgrep/12.1.1/crates/core/app.rs:417:57 clippy::match_same_arms "this `match` has identical arm bodies"
-ripgrep/12.1.1/crates/core/app.rs:417:57 clippy::match_same_arms "this `match` has identical arm bodies"
-ripgrep/12.1.1/crates/core/app.rs:417:57 clippy::match_same_arms "this `match` has identical arm bodies"
-ripgrep/12.1.1/crates/core/app.rs:75:9 clippy::doc_markdown "you should put `RIPGREP_BUILD_GIT_HASH` between ticks in the documentation"
-ripgrep/12.1.1/crates/core/app.rs:75:9 clippy::doc_markdown "you should put `RIPGREP_BUILD_GIT_HASH` between ticks in the documentation"
-ripgrep/12.1.1/crates/core/app.rs:87:5 clippy::if_not_else "unnecessary boolean `not` operation"
-ripgrep/12.1.1/crates/core/app.rs:87:5 clippy::if_not_else "unnecessary boolean `not` operation"
-ripgrep/12.1.1/crates/core/args.rs:1143:22 clippy::unused_self "unused `self` argument"
-ripgrep/12.1.1/crates/core/args.rs:11:1 clippy::single_component_path_imports "this import is redundant"
-ripgrep/12.1.1/crates/core/args.rs:1209:74 clippy::if_same_then_else "this `if` has identical blocks"
-ripgrep/12.1.1/crates/core/args.rs:1282:13 clippy::similar_names "binding's name is too similar to existing binding"
-ripgrep/12.1.1/crates/core/args.rs:1430:22 clippy::unused_self "unused `self` argument"
-ripgrep/12.1.1/crates/core/args.rs:1438:21 clippy::doc_markdown "you should put `OsStr` between ticks in the documentation"
-ripgrep/12.1.1/crates/core/args.rs:1520:44 clippy::redundant_closure_for_method_calls "redundant closure found"
-ripgrep/12.1.1/crates/core/args.rs:1524:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
-ripgrep/12.1.1/crates/core/args.rs:1635:14 clippy::doc_markdown "you should put `values_of_lossy` between ticks in the documentation"
-ripgrep/12.1.1/crates/core/args.rs:1693:41 clippy::redundant_closure_for_method_calls "redundant closure found"
-ripgrep/12.1.1/crates/core/args.rs:1770:17 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
-ripgrep/12.1.1/crates/core/args.rs:287:13 clippy::similar_names "binding's name is too similar to existing binding"
-ripgrep/12.1.1/crates/core/args.rs:33:1 clippy::single_component_path_imports "this import is redundant"
-ripgrep/12.1.1/crates/core/args.rs:34:1 clippy::single_component_path_imports "this import is redundant"
-ripgrep/12.1.1/crates/core/args.rs:35:1 clippy::single_component_path_imports "this import is redundant"
-ripgrep/12.1.1/crates/core/args.rs:369:5 clippy::upper_case_acronyms "name `JSON` contains a capitalized acronym"
-ripgrep/12.1.1/crates/core/args.rs:410:14 clippy::trivially_copy_pass_by_ref "this argument (2 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
-ripgrep/12.1.1/crates/core/args.rs:475:18 clippy::match_same_arms "this `match` has identical arm bodies"
-ripgrep/12.1.1/crates/core/args.rs:512:19 clippy::doc_markdown "you should put `ArgMatches` between ticks in the documentation"
-ripgrep/12.1.1/crates/core/args.rs:549:16 clippy::wrong_self_convention "methods called `to_*` usually take self by reference; consider choosing a less ambiguous name"
-ripgrep/12.1.1/crates/core/args.rs:71:5 clippy::upper_case_acronyms "name `PCRE2Version` contains a capitalized acronym"
-ripgrep/12.1.1/crates/core/args.rs:76:18 clippy::trivially_copy_pass_by_ref "this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
-ripgrep/12.1.1/crates/core/args.rs:77:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
-ripgrep/12.1.1/crates/core/args.rs:923:42 clippy::doc_markdown "you should put `BinaryDetection::quit` between ticks in the documentation"
-ripgrep/12.1.1/crates/core/config.rs:13:1 clippy::single_component_path_imports "this import is redundant"
-ripgrep/12.1.1/crates/core/config.rs:58:6 clippy::type_complexity "very complex type used. Consider factoring parts into `type` definitions"
-ripgrep/12.1.1/crates/core/config.rs:79:6 clippy::type_complexity "very complex type used. Consider factoring parts into `type` definitions"
-ripgrep/12.1.1/crates/core/logger.rs:11:30 clippy::doc_markdown "you should put `max_level` between ticks in the documentation"
-ripgrep/12.1.1/crates/core/logger.rs:15:16 clippy::redundant_static_lifetimes "constants have by default a `'static` lifetime"
-ripgrep/12.1.1/crates/core/main.rs:55:19 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
-ripgrep/12.1.1/crates/core/main.rs:56:9 clippy::enum_glob_use "usage of wildcard import for enum variants"
-ripgrep/12.1.1/crates/core/messages.rs:46:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-ripgrep/12.1.1/crates/core/messages.rs:51:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-ripgrep/12.1.1/crates/core/messages.rs:62:1 clippy::module_name_repetitions "item name ends with its containing module's name"
-ripgrep/12.1.1/crates/core/path_printer.rs:27:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-ripgrep/12.1.1/crates/core/path_printer.rs:89:9 clippy::if_not_else "unnecessary boolean `not` operation"
-ripgrep/12.1.1/crates/core/search.rs:185:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-ripgrep/12.1.1/crates/core/search.rs:224:5 clippy::upper_case_acronyms "name `JSON` contains a capitalized acronym"
-ripgrep/12.1.1/crates/core/search.rs:292:9 clippy::write_with_newline "using `write!()` with a format string that ends in a single newline"
-ripgrep/12.1.1/crates/core/search.rs:311:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-ripgrep/12.1.1/crates/core/search.rs:377:12 clippy::nonminimal_bool "this boolean expression can be simplified"
-ripgrep/12.1.1/crates/core/search.rs:423:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
-ripgrep/12.1.1/crates/core/search.rs:447:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
-ripgrep/12.1.1/crates/core/search.rs:472:24 clippy::map_clone "you are using an explicit closure for cloning elements"
-ripgrep/12.1.1/crates/core/search.rs:472:41 clippy::redundant_closure_for_method_calls "redundant closure found"
-ripgrep/12.1.1/crates/core/search.rs:480:24 clippy::map_clone "you are using an explicit closure for cloning elements"
-ripgrep/12.1.1/crates/core/search.rs:480:41 clippy::redundant_closure_for_method_calls "redundant closure found"
-ripgrep/12.1.1/crates/core/search.rs:49:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-ripgrep/12.1.1/crates/core/search.rs:509:24 clippy::map_clone "you are using an explicit closure for cloning elements"
-ripgrep/12.1.1/crates/core/search.rs:509:41 clippy::redundant_closure_for_method_calls "redundant closure found"
-ripgrep/12.1.1/crates/core/search.rs:517:24 clippy::map_clone "you are using an explicit closure for cloning elements"
-ripgrep/12.1.1/crates/core/search.rs:517:41 clippy::redundant_closure_for_method_calls "redundant closure found"
-ripgrep/12.1.1/crates/core/search.rs:533:36 clippy::cast_lossless "casting `u32` to `f64` may become silently lossy if you later change the type"
-ripgrep/12.1.1/crates/core/search.rs:533:5 clippy::cast_precision_loss "casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
-ripgrep/12.1.1/crates/core/subject.rs:20:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-ripgrep/12.1.1/crates/core/subject.rs:4:1 clippy::single_component_path_imports "this import is redundant"
-syn/1.0.54/build.rs:1:null clippy::cargo_common_metadata "package `syn` is missing `package.keywords` metadata"
-syn/1.0.54/build.rs:1:null clippy::multiple_crate_versions "could not read cargo metadata: `cargo metadata` exited with an error:  Downloading crates ...\n  Downloaded syn-test-suite v0.0.0\nerror: failed to verify the checksum of `syn-test-suite v0.0.0`"
-syn/1.0.54/src/lib.rs:1:null clippy::cargo_common_metadata "package `syn` is missing `package.keywords` metadata"
-syn/1.0.54/src/lib.rs:1:null clippy::multiple_crate_versions "could not read cargo metadata: `cargo metadata` exited with an error:  Downloading crates ...\n  Downloaded syn-test-suite v0.0.0\nerror: failed to verify the checksum of `syn-test-suite v0.0.0`"
-syn/1.0.54/src/lit.rs:1397:40 clippy::redundant_else "redundant else block"
-syn/1.0.54/src/lit.rs:1405:28 clippy::redundant_else "redundant else block"
-syn/1.0.54/src/lit.rs:1485:32 clippy::redundant_else "redundant else block"
-unicode-xid/0.2.1/src/lib.rs:1:null clippy::cargo_common_metadata "package `unicode-xid` is missing `package.categories` metadata"
-unicode-xid/0.2.1/src/lib.rs:56:11 clippy::upper_case_acronyms "name `UnicodeXID` contains a capitalized acronym"
-unicode-xid/0.2.1/src/lib.rs:57:64 clippy::doc_markdown "you should put `XID_Start` between ticks in the documentation"
-unicode-xid/0.2.1/src/lib.rs:60:10 clippy::doc_markdown "you should put `XID_Start` between ticks in the documentation"
-unicode-xid/0.2.1/src/lib.rs:62:27 clippy::doc_markdown "you should put `ID_Start` between ticks in the documentation"
-unicode-xid/0.2.1/src/lib.rs:62:67 clippy::doc_markdown "you should put `NFKx` between ticks in the documentation"
-unicode-xid/0.2.1/src/lib.rs:63:21 clippy::wrong_self_convention "methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name"
-unicode-xid/0.2.1/src/lib.rs:65:61 clippy::doc_markdown "you should put `XID_Continue` between ticks in the documentation"
-unicode-xid/0.2.1/src/lib.rs:68:10 clippy::doc_markdown "you should put `XID_Continue` between ticks in the documentation"
-unicode-xid/0.2.1/src/lib.rs:70:28 clippy::doc_markdown "you should put `ID_Continue` between ticks in the documentation"
-unicode-xid/0.2.1/src/lib.rs:70:72 clippy::doc_markdown "you should put `NFKx` between ticks in the documentation"
-unicode-xid/0.2.1/src/lib.rs:71:24 clippy::wrong_self_convention "methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name"
-xsv/0.13.0/src/cmd/cat.rs:101:34 clippy::redundant_closure_for_method_calls "redundant closure found"
-xsv/0.13.0/src/cmd/cat.rs:42:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
-xsv/0.13.0/src/cmd/cat.rs:53:9 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/cmd/cat.rs:7:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
-xsv/0.13.0/src/cmd/count.rs:32:9 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/cmd/count.rs:38:9 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-xsv/0.13.0/src/cmd/count.rs:42:33 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-xsv/0.13.0/src/cmd/count.rs:50:5 clippy::unit_arg "passing a unit value to a function"
-xsv/0.13.0/src/cmd/count.rs:7:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
-xsv/0.13.0/src/cmd/fixlengths.rs:45:9 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/cmd/fixlengths.rs:50:18 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-xsv/0.13.0/src/cmd/fixlengths.rs:62:30 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-xsv/0.13.0/src/cmd/fixlengths.rs:9:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
-xsv/0.13.0/src/cmd/flatten.rs:10:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
-xsv/0.13.0/src/cmd/flatten.rs:51:9 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/cmd/fmt.rs:50:9 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/cmd/fmt.rs:55:13 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/cmd/fmt.rs:7:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
-xsv/0.13.0/src/cmd/frequency.rs:148:43 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
-xsv/0.13.0/src/cmd/frequency.rs:149:43 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
-xsv/0.13.0/src/cmd/frequency.rs:15:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
-xsv/0.13.0/src/cmd/frequency.rs:169:13 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/cmd/frequency.rs:176:17 clippy::if_not_else "unnecessary boolean `not` operation"
-xsv/0.13.0/src/cmd/frequency.rs:178:24 clippy::collapsible_else_if "this `else { if .. }` block can be collapsed"
-xsv/0.13.0/src/cmd/frequency.rs:77:9 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/cmd/frequency.rs:93:31 clippy::explicit_into_iter_loop "it is more concise to loop over containers instead of using explicit iteration methods"
-xsv/0.13.0/src/cmd/headers.rs:43:9 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/cmd/headers.rs:49:17 clippy::explicit_into_iter_loop "it is more concise to loop over containers instead of using explicit iteration methods"
-xsv/0.13.0/src/cmd/headers.rs:9:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
-xsv/0.13.0/src/cmd/index.rs:11:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
-xsv/0.13.0/src/cmd/index.rs:45:9 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/cmd/input.rs:42:9 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/cmd/input.rs:47:9 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/cmd/input.rs:7:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
-xsv/0.13.0/src/cmd/join.rs:17:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
-xsv/0.13.0/src/cmd/join.rs:194:29 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/cmd/join.rs:224:22 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/cmd/join.rs:293:14 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/cmd/join.rs:293:20 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/cmd/join.rs:297:13 clippy::redundant_field_names "redundant field names in struct initialization"
-xsv/0.13.0/src/cmd/join.rs:298:13 clippy::redundant_field_names "redundant field names in struct initialization"
-xsv/0.13.0/src/cmd/join.rs:299:13 clippy::redundant_field_names "redundant field names in struct initialization"
-xsv/0.13.0/src/cmd/join.rs:300:13 clippy::redundant_field_names "redundant field names in struct initialization"
-xsv/0.13.0/src/cmd/join.rs:308:9 clippy::unused_self "unused `self` argument"
-xsv/0.13.0/src/cmd/join.rs:342:38 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-xsv/0.13.0/src/cmd/join.rs:342:46 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
-xsv/0.13.0/src/cmd/join.rs:347:9 clippy::if_not_else "unnecessary boolean `not` operation"
-xsv/0.13.0/src/cmd/join.rs:372:44 clippy::redundant_closure_for_method_calls "redundant closure found"
-xsv/0.13.0/src/cmd/join.rs:375:33 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/cmd/join.rs:392:13 clippy::redundant_field_names "redundant field names in struct initialization"
-xsv/0.13.0/src/cmd/join.rs:403:29 clippy::explicit_into_iter_loop "it is more concise to loop over containers instead of using explicit iteration methods"
-xsv/0.13.0/src/cmd/join.rs:426:13 clippy::if_not_else "unnecessary boolean `not` operation"
-xsv/0.13.0/src/cmd/join.rs:77:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
-xsv/0.13.0/src/cmd/join.rs:94:9 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/cmd/partition.rs:105:22 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/cmd/partition.rs:106:22 clippy::redundant_slicing "redundant slicing of the whole range"
-xsv/0.13.0/src/cmd/partition.rs:139:13 clippy::redundant_field_names "redundant field names in struct initialization"
-xsv/0.13.0/src/cmd/partition.rs:15:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
-xsv/0.13.0/src/cmd/partition.rs:169:9 clippy::if_not_else "unnecessary boolean `not` operation"
-xsv/0.13.0/src/cmd/partition.rs:56:9 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/cmd/partition.rs:77:9 clippy::unused_self "unused `self` argument"
-xsv/0.13.0/src/cmd/sample.rs:105:44 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
-xsv/0.13.0/src/cmd/sample.rs:115:21 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
-xsv/0.13.0/src/cmd/sample.rs:11:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
-xsv/0.13.0/src/cmd/sample.rs:51:9 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/cmd/sample.rs:58:19 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-xsv/0.13.0/src/cmd/sample.rs:69:9 clippy::match_wildcard_for_single_variants "wildcard match will miss any future added variants"
-xsv/0.13.0/src/cmd/sample.rs:75:16 clippy::explicit_into_iter_loop "it is more concise to loop over containers instead of using explicit iteration methods"
-xsv/0.13.0/src/cmd/sample.rs:91:42 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
-xsv/0.13.0/src/cmd/sample.rs:92:43 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
-xsv/0.13.0/src/cmd/search.rs:51:9 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/cmd/search.rs:9:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
-xsv/0.13.0/src/cmd/select.rs:60:9 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/cmd/select.rs:8:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
-xsv/0.13.0/src/cmd/slice.rs:57:9 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/cmd/slice.rs:9:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
-xsv/0.13.0/src/cmd/sort.rs:11:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
-xsv/0.13.0/src/cmd/sort.rs:138:47 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
-xsv/0.13.0/src/cmd/sort.rs:139:51 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
-xsv/0.13.0/src/cmd/sort.rs:48:9 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/cmd/sort.rs:91:14 clippy::explicit_into_iter_loop "it is more concise to loop over containers instead of using explicit iteration methods"
-xsv/0.13.0/src/cmd/split.rs:14:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
-xsv/0.13.0/src/cmd/split.rs:61:9 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/cmd/split.rs:94:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
-xsv/0.13.0/src/cmd/split.rs:96:14 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
-xsv/0.13.0/src/cmd/split.rs:99:13 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
-xsv/0.13.0/src/cmd/stats.rs:110:36 clippy::redundant_closure_for_method_calls "redundant closure found"
-xsv/0.13.0/src/cmd/stats.rs:127:14 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
-xsv/0.13.0/src/cmd/stats.rs:138:43 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
-xsv/0.13.0/src/cmd/stats.rs:139:43 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
-xsv/0.13.0/src/cmd/stats.rs:162:25 clippy::explicit_into_iter_loop "it is more concise to loop over containers instead of using explicit iteration methods"
-xsv/0.13.0/src/cmd/stats.rs:22:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
-xsv/0.13.0/src/cmd/stats.rs:231:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
-xsv/0.13.0/src/cmd/stats.rs:262:35 clippy::default_trait_access "calling `cmd::stats::TypedSum::default()` is more clear than this expression"
-xsv/0.13.0/src/cmd/stats.rs:263:40 clippy::default_trait_access "calling `cmd::stats::TypedMinMax::default()` is more clear than this expression"
-xsv/0.13.0/src/cmd/stats.rs:264:39 clippy::default_trait_access "calling `stats::OnlineStats::default()` is more clear than this expression"
-xsv/0.13.0/src/cmd/stats.rs:265:58 clippy::default_trait_access "calling `stats::Unsorted::default()` is more clear than this expression"
-xsv/0.13.0/src/cmd/stats.rs:266:41 clippy::default_trait_access "calling `stats::Unsorted::default()` is more clear than this expression"
-xsv/0.13.0/src/cmd/stats.rs:268:18 clippy::default_trait_access "calling `cmd::stats::FieldType::default()` is more clear than this expression"
-xsv/0.13.0/src/cmd/stats.rs:269:13 clippy::redundant_field_names "redundant field names in struct initialization"
-xsv/0.13.0/src/cmd/stats.rs:270:13 clippy::redundant_field_names "redundant field names in struct initialization"
-xsv/0.13.0/src/cmd/stats.rs:271:13 clippy::redundant_field_names "redundant field names in struct initialization"
-xsv/0.13.0/src/cmd/stats.rs:272:13 clippy::redundant_field_names "redundant field names in struct initialization"
-xsv/0.13.0/src/cmd/stats.rs:273:13 clippy::redundant_field_names "redundant field names in struct initialization"
-xsv/0.13.0/src/cmd/stats.rs:274:13 clippy::redundant_field_names "redundant field names in struct initialization"
-xsv/0.13.0/src/cmd/stats.rs:283:9 clippy::option_map_unit_fn "called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`"
-xsv/0.13.0/src/cmd/stats.rs:284:9 clippy::option_map_unit_fn "called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`"
-xsv/0.13.0/src/cmd/stats.rs:285:9 clippy::option_map_unit_fn "called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`"
-xsv/0.13.0/src/cmd/stats.rs:290:21 clippy::option_map_unit_fn "called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`"
-xsv/0.13.0/src/cmd/stats.rs:293:25 clippy::match_same_arms "this `match` has identical arm bodies"
-xsv/0.13.0/src/cmd/stats.rs:297:25 clippy::option_map_unit_fn "called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`"
-xsv/0.13.0/src/cmd/stats.rs:301:21 clippy::option_map_unit_fn "called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`"
-xsv/0.13.0/src/cmd/stats.rs:302:21 clippy::option_map_unit_fn "called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`"
-xsv/0.13.0/src/cmd/stats.rs:308:18 clippy::wrong_self_convention "methods called `to_*` usually take self by reference; consider choosing a less ambiguous name"
-xsv/0.13.0/src/cmd/stats.rs:318:9 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-xsv/0.13.0/src/cmd/stats.rs:322:45 clippy::redundant_closure_for_method_calls "redundant closure found"
-xsv/0.13.0/src/cmd/stats.rs:322:9 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-xsv/0.13.0/src/cmd/stats.rs:327:9 clippy::if_not_else "unnecessary boolean `not` operation"
-xsv/0.13.0/src/cmd/stats.rs:330:13 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
-xsv/0.13.0/src/cmd/stats.rs:338:45 clippy::redundant_closure_for_method_calls "redundant closure found"
-xsv/0.13.0/src/cmd/stats.rs:402:16 clippy::redundant_pattern_matching "redundant pattern matching, consider using `is_ok()`"
-xsv/0.13.0/src/cmd/stats.rs:403:16 clippy::redundant_pattern_matching "redundant pattern matching, consider using `is_ok()`"
-xsv/0.13.0/src/cmd/stats.rs:407:18 clippy::trivially_copy_pass_by_ref "this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
-xsv/0.13.0/src/cmd/stats.rs:411:16 clippy::trivially_copy_pass_by_ref "this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
-xsv/0.13.0/src/cmd/stats.rs:427:56 clippy::match_same_arms "this `match` has identical arm bodies"
-xsv/0.13.0/src/cmd/stats.rs:429:56 clippy::match_same_arms "this `match` has identical arm bodies"
-xsv/0.13.0/src/cmd/stats.rs:430:60 clippy::match_same_arms "this `match` has identical arm bodies"
-xsv/0.13.0/src/cmd/stats.rs:430:60 clippy::match_same_arms "this `match` has identical arm bodies"
-xsv/0.13.0/src/cmd/stats.rs:454:5 clippy::doc_markdown "you should put `TypedSum` between ticks in the documentation"
-xsv/0.13.0/src/cmd/stats.rs:473:43 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
-xsv/0.13.0/src/cmd/stats.rs:504:56 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
-xsv/0.13.0/src/cmd/stats.rs:505:51 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
-xsv/0.13.0/src/cmd/stats.rs:511:5 clippy::doc_markdown "you should put `TypedMinMax` between ticks in the documentation"
-xsv/0.13.0/src/cmd/stats.rs:536:35 clippy::cast_possible_truncation "casting `f64` to `i64` may truncate the value"
-xsv/0.13.0/src/cmd/stats.rs:544:33 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
-xsv/0.13.0/src/cmd/stats.rs:592:22 clippy::default_trait_access "calling `stats::MinMax::default()` is more clear than this expression"
-xsv/0.13.0/src/cmd/stats.rs:593:22 clippy::default_trait_access "calling `stats::MinMax::default()` is more clear than this expression"
-xsv/0.13.0/src/cmd/stats.rs:594:23 clippy::default_trait_access "calling `stats::MinMax::default()` is more clear than this expression"
-xsv/0.13.0/src/cmd/stats.rs:595:21 clippy::default_trait_access "calling `stats::MinMax::default()` is more clear than this expression"
-xsv/0.13.0/src/cmd/stats.rs:71:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
-xsv/0.13.0/src/cmd/stats.rs:86:9 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/cmd/table.rs:10:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
-xsv/0.13.0/src/cmd/table.rs:50:9 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/cmd/table.rs:54:9 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/config.rs:113:43 clippy::or_fun_call "use of `unwrap_or` followed by a function call"
-xsv/0.13.0/src/config.rs:58:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
-xsv/0.13.0/src/config.rs:77:28 clippy::explicit_deref_methods "explicit deref method call"
-xsv/0.13.0/src/config.rs:90:13 clippy::redundant_field_names "redundant field names in struct initialization"
-xsv/0.13.0/src/index.rs:31:13 clippy::redundant_field_names "redundant field names in struct initialization"
-xsv/0.13.0/src/main.rs:164:49 clippy::redundant_clone "redundant clone"
-xsv/0.13.0/src/main.rs:1:null clippy::cargo_common_metadata "package `xsv` is missing `package.categories` metadata"
-xsv/0.13.0/src/main.rs:1:null clippy::multiple_crate_versions "multiple versions for dependency `rand_core`: 0.3.1, 0.4.2"
-xsv/0.13.0/src/main.rs:1:null clippy::multiple_crate_versions "multiple versions for dependency `rand`: 0.3.23, 0.4.6"
-xsv/0.13.0/src/main.rs:75:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
-xsv/0.13.0/src/select.rs:13:1 clippy::module_name_repetitions "item name starts with its containing module's name"
-xsv/0.13.0/src/select.rs:154:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
-xsv/0.13.0/src/select.rs:250:33 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/select.rs:250:43 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/select.rs:255:39 clippy::range_plus_one "an inclusive range would be more readable"
-xsv/0.13.0/src/select.rs:280:20 clippy::len_zero "length comparison to zero"
-xsv/0.13.0/src/select.rs:29:13 clippy::redundant_field_names "redundant field names in struct initialization"
-xsv/0.13.0/src/select.rs:360:62 clippy::trivially_copy_pass_by_ref "this argument (8 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
-xsv/0.13.0/src/select.rs:360:9 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Option`"
-xsv/0.13.0/src/select.rs:375:9 clippy::stable_sort_primitive "used `sort` on primitive type `usize`"
-xsv/0.13.0/src/select.rs:379:18 clippy::explicit_into_iter_loop "it is more concise to loop over containers instead of using explicit iteration methods"
-xsv/0.13.0/src/select.rs:416:5 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
-xsv/0.13.0/src/select.rs:419:9 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Option`"
-xsv/0.13.0/src/select.rs:420:27 clippy::option_option "consider using `Option<T>` instead of `Option<Option<T>>` or a custom enum if you need to distinguish all 3 cases"
-xsv/0.13.0/src/select.rs:99:17 clippy::similar_names "binding's name is too similar to existing binding"
-xsv/0.13.0/src/util.rs:150:5 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
-xsv/0.13.0/src/util.rs:37:33 clippy::map_clone "you are using an explicit closure for copying elements"
-xsv/0.13.0/src/util.rs:90:1 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
+cargo-0.49.0//home/matthias/.rustup/toolchains/nightly-2021-01-15-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:393:34 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/build.rs:1:null clippy::cargo_common_metadata "package `cargo` is missing `package.categories` metadata"
+cargo-0.49.0/build.rs:1:null clippy::cargo_common_metadata "package `cargo` is missing `package.keywords` metadata"
+cargo-0.49.0/src/bin/cargo/cli.rs:104:34 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+cargo-0.49.0/src/bin/cargo/cli.rs:121:5 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
+cargo-0.49.0/src/bin/cargo/cli.rs:157:30 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/bin/cargo/cli.rs:184:41 clippy::cast_possible_truncation "casting `u64` to `u32` may truncate the value"
+cargo-0.49.0/src/bin/cargo/cli.rs:196:42 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/bin/cargo/cli.rs:200:39 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/bin/cargo/cli.rs:231:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+cargo-0.49.0/src/bin/cargo/cli.rs:245:22 clippy::cast_possible_truncation "casting `u64` to `u32` may truncate the value"
+cargo-0.49.0/src/bin/cargo/cli.rs:247:47 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/bin/cargo/cli.rs:257:22 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/bin/cargo/cli.rs:26:20 clippy::redundant_else "redundant else block"
+cargo-0.49.0/src/bin/cargo/cli.rs:7:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/commands/bench.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/commands/bench.rs:76:59 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/bin/cargo/commands/build.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/commands/check.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/commands/clean.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/commands/doc.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/commands/fetch.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/commands/fix.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/commands/generate_lockfile.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/commands/git_checkout.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/commands/help.rs:20:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo-0.49.0/src/bin/cargo/commands/init.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/commands/install.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/commands/install.rs:97:16 clippy::option_if_let_else "use Option::map_or instead of an if let/else"
+cargo-0.49.0/src/bin/cargo/commands/locate_project.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/commands/login.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/commands/metadata.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/commands/mod.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/commands/new.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/commands/new.rs:20:24 clippy::option_if_let_else "use Option::map_or instead of an if let/else"
+cargo-0.49.0/src/bin/cargo/commands/owner.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/commands/owner.rs:38:43 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/bin/cargo/commands/owner.rs:39:43 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/bin/cargo/commands/owner.rs:40:43 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/bin/cargo/commands/owner.rs:43:30 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/bin/cargo/commands/owner.rs:46:30 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/bin/cargo/commands/package.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/commands/pkgid.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/commands/publish.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/commands/publish.rs:40:47 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/bin/cargo/commands/read_manifest.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/commands/run.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/commands/rustc.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/commands/rustdoc.rs:3:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/commands/search.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/commands/test.rs:127:54 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/bin/cargo/commands/test.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/commands/tree.rs:149:49 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/bin/cargo/commands/tree.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/commands/uninstall.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/commands/update.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/commands/vendor.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/commands/vendor.rs:96:16 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
+cargo-0.49.0/src/bin/cargo/commands/verify_project.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/commands/version.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/commands/yank.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/commands/yank.rs:32:36 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/bin/cargo/commands/yank.rs:33:35 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/bin/cargo/commands/yank.rs:34:36 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/bin/cargo/commands/yank.rs:35:36 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/bin/cargo/main.rs:100:17 clippy::match_wildcard_for_single_variants "wildcard match will miss any future added variants"
+cargo-0.49.0/src/bin/cargo/main.rs:118:41 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/bin/cargo/main.rs:137:43 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/bin/cargo/main.rs:148:19 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+cargo-0.49.0/src/bin/cargo/main.rs:174:57 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/bin/cargo/main.rs:18:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/bin/cargo/main.rs:1:null clippy::cargo_common_metadata "package `cargo` is missing `package.categories` metadata"
+cargo-0.49.0/src/bin/cargo/main.rs:1:null clippy::cargo_common_metadata "package `cargo` is missing `package.keywords` metadata"
+cargo-0.49.0/src/bin/cargo/main.rs:1:null clippy::multiple_crate_versions "multiple versions for dependency `crossbeam-utils`: 0.6.6, 0.7.2"
+cargo-0.49.0/src/bin/cargo/main.rs:1:null clippy::multiple_crate_versions "multiple versions for dependency `hex`: 0.3.2, 0.4.0"
+cargo-0.49.0/src/bin/cargo/main.rs:1:null clippy::multiple_crate_versions "multiple versions for dependency `humantime`: 1.3.0, 2.0.0"
+cargo-0.49.0/src/bin/cargo/main.rs:72:22 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/bin/cargo/main.rs:94:13 clippy::match_wildcard_for_single_variants "wildcard match will miss any future added variants"
+cargo-0.49.0/src/bin/cargo/main.rs:96:41 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/bin/cargo/main.rs:98:60 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/compiler/build_config.rs:155:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+cargo-0.49.0/src/cargo/core/compiler/build_config.rs:170:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/compiler/build_config.rs:175:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/compiler/build_config.rs:180:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/compiler/build_config.rs:186:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/compiler/build_config.rs:197:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/compiler/build_config.rs:205:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/compiler/build_config.rs:51:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/compiler/build_config.rs:69:48 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+cargo-0.49.0/src/cargo/core/compiler/build_config.rs:96:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/compiler/build_context/mod.rs:44:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/compiler/build_context/mod.rs:83:20 clippy::doc_markdown "you should put `x86_64` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:108:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:121:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:149:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:411:9 clippy::needless_question_mark "Question mark operator is useless here"
+cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:420:69 clippy::doc_markdown "you should put `mode/target_kind` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:423:19 clippy::doc_markdown "you should put `CrateTypes` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:424:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:469:58 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:603:19 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:665:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:82:31 clippy::doc_markdown "you should put `FileType` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:83:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:84:9 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:96:31 clippy::doc_markdown "you should put `FileType` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/compiler/build_context/target_info.rs:98:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/compiler/build_plan.rs:4:9 clippy::doc_markdown "you should put `BuildPlan` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/compiler/build_plan.rs:5:66 clippy::doc_markdown "you should put `BuildPlan` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/compiler/build_plan.rs:66:40 clippy::ptr_arg "writing `&PathBuf` instead of `&Path` involves a new object where a slice will do."
+cargo-0.49.0/src/cargo/core/compiler/compilation.rs:150:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/compiler/compilation.rs:169:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/compiler/compilation.rs:185:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/compiler/compilation.rs:193:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/compiler/compilation.rs:194:49 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/compiler/compilation.rs:198:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/compiler/compilation.rs:314:16 clippy::doc_markdown "you should put `rustc_tool` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/compiler/compilation.rs:91:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/compiler/compile_kind.rs:118:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/compiler/compile_kind.rs:123:18 clippy::case_sensitive_file_extension_comparisons "case-sensitive file extension comparison"
+cargo-0.49.0/src/cargo/core/compiler/compile_kind.rs:147:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/compiler/compile_kind.rs:157:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/compiler/compile_kind.rs:29:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/compiler/compile_kind.rs:33:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/compiler/compile_kind.rs:49:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/compiler/compile_kind.rs:69:48 clippy::case_sensitive_file_extension_comparisons "case-sensitive file extension comparison"
+cargo-0.49.0/src/cargo/core/compiler/context/compilation_files.rs:204:9 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+cargo-0.49.0/src/cargo/core/compiler/context/compilation_files.rs:277:22 clippy::doc_markdown "you should put `OUT_DIR` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/compiler/context/compilation_files.rs:324:66 clippy::doc_markdown "you should put `FileType` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/compiler/context/compilation_files.rs:393:37 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/core/compiler/context/compilation_files.rs:426:71 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:125:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:125:5 clippy::too_many_lines "this function has too many lines (107/100)"
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:270:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:286:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:308:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:340:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:349:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:354:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:358:21 clippy::doc_markdown "you should put `RunCustomBuild` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:361:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:374:43 clippy::doc_markdown "you should put `RunCustomBuild` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:378:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:383:41 clippy::doc_markdown "you should put `RunCustomBuild` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:384:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:391:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:397:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:523:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:538:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:542:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:83:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/compiler/context/mod.rs:92:25 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+cargo-0.49.0/src/cargo/core/compiler/crate_type.rs:16:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/compiler/crate_type.rs:29:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/compiler/crate_type.rs:40:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/compiler/crate_type.rs:49:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/compiler/crate_type.rs:60:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:150:1 clippy::too_many_lines "this function has too many lines (230/100)"
+cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:353:56 clippy::manual_strip "stripping a prefix manually"
+cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:448:27 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:464:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:481:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:48:56 clippy::doc_markdown "you should put `RunCustomBuild` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:561:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:567:20 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:576:28 clippy::shadow_unrelated "`mut value` is being shadowed"
+cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:606:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:688:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:756:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:762:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:762:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+cargo-0.49.0/src/cargo/core/compiler/custom_build.rs:823:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1021:51 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1656:16 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1664:5 clippy::field_reassign_with_default "field assignment outside of initializer for an instance created with Default::default()"
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1787:5 clippy::similar_names "binding's name is too similar to existing binding"
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1795:5 clippy::field_reassign_with_default "field assignment outside of initializer for an instance created with Default::default()"
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1882:17 clippy::similar_names "binding's name is too similar to existing binding"
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1894:17 clippy::similar_names "binding's name is too similar to existing binding"
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1906:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1917:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1923:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1956:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1962:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1963:22 clippy::cast_possible_truncation "casting `usize` to `u8` may truncate the value"
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1964:22 clippy::cast_possible_truncation "casting `usize` to `u8` may truncate the value"
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1965:22 clippy::cast_possible_truncation "casting `usize` to `u8` may truncate the value"
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1966:22 clippy::cast_possible_truncation "casting `usize` to `u8` may truncate the value"
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1980:17 clippy::similar_names "binding's name is too similar to existing binding"
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1980:24 clippy::manual_strip "stripping a prefix manually"
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:1986:17 clippy::similar_names "binding's name is too similar to existing binding"
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:2016:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:61:5 clippy::doc_markdown "you should put `CompileMode` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:63:12 clippy::doc_markdown "you should put `CompileKind` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:67:7 clippy::doc_markdown "you should put `CARGO_DEFAULT_LIB_METADATA[^4` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:68:5 clippy::doc_markdown "you should put `package_id` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:71:19 clippy::doc_markdown "you should put `test/bench/for_host/edition` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:755:52 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:77:5 clippy::doc_markdown "you should put `is_std` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:816:5 clippy::too_many_lines "this function has too many lines (127/100)"
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:863:64 clippy::similar_names "binding's name is too similar to existing binding"
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:875:33 clippy::similar_names "binding's name is too similar to existing binding"
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:876:32 clippy::similar_names "binding's name is too similar to existing binding"
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:896:30 clippy::similar_names "binding's name is too similar to existing binding"
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:897:30 clippy::similar_names "binding's name is too similar to existing binding"
+cargo-0.49.0/src/cargo/core/compiler/fingerprint.rs:991:37 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:12:5 clippy::doc_markdown "you should put `src/librustc_jobserver/lib.rs` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:329:13 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:332:23 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:34:53 clippy::doc_markdown "you should put `NeedsToken` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:35:6 clippy::doc_markdown "you should put `ReleaseToken` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:37:6 clippy::doc_markdown "you should put `NeedsToken` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:40:5 clippy::doc_markdown "you should put `NeedsToken` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:40:56 clippy::doc_markdown "you should put `NeedsToken` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:43:6 clippy::doc_markdown "you should put `ReleaseToken` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:748:16 clippy::collapsible_else_if "this `else { if .. }` block can be collapsed"
+cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:749:13 clippy::if_not_else "unnecessary boolean `not` operation"
+cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:786:26 clippy::unused_self "unused `self` argument"
+cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:81:61 clippy::doc_markdown "you should put `DrainState` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:865:13 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:871:13 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:890:9 clippy::unused_self "unused `self` argument"
+cargo-0.49.0/src/cargo/core/compiler/job_queue.rs:93:24 clippy::doc_markdown "you should put `JobQueue` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/compiler/links.rs:8:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:1016:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:1094:19 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:1131:1 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:1268:34 clippy::case_sensitive_file_extension_comparisons "case-sensitive file extension comparison"
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:1277:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:179:1 clippy::too_many_lines "this function has too many lines (162/100)"
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:198:78 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:201:25 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:267:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:324:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:364:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:364:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:392:45 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:415:23 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:464:18 clippy::ptr_arg "writing `&PathBuf` instead of `&Path` involves a new object where a slice will do."
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:488:61 clippy::ptr_arg "writing `&PathBuf` instead of `&Path` involves a new object where a slice will do."
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:667:15 clippy::similar_names "binding's name is too similar to existing binding"
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:693:1 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:725:42 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:736:1 clippy::too_many_lines "this function has too many lines (141/100)"
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:73:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:777:12 clippy::if_not_else "unnecessary boolean `not` operation"
+cargo-0.49.0/src/cargo/core/compiler/mod.rs:873:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/core/compiler/output_depinfo.rs:41:13 clippy::match_wildcard_for_single_variants "wildcard match will miss any future added variants"
+cargo-0.49.0/src/cargo/core/compiler/rustdoc.rs:16:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/core/compiler/rustdoc.rs:57:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/core/compiler/rustdoc.rs:72:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/compiler/standard_lib.rs:134:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/compiler/standard_lib.rs:16:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/compiler/standard_lib.rs:30:28 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/compiler/standard_lib.rs:34:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/compiler/timings.rs:16:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+cargo-0.49.0/src/cargo/core/compiler/timings.rs:192:64 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+cargo-0.49.0/src/cargo/core/compiler/timings.rs:212:58 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+cargo-0.49.0/src/cargo/core/compiler/timings.rs:234:13 clippy::let_underscore_drop "non-binding `let` on a type that implements `Drop`"
+cargo-0.49.0/src/cargo/core/compiler/timings.rs:355:13 clippy::cast_possible_truncation "casting `f64` to `u32` may truncate the value"
+cargo-0.49.0/src/cargo/core/compiler/timings.rs:355:13 clippy::cast_sign_loss "casting `f64` to `u32` may lose the sign of the value"
+cargo-0.49.0/src/cargo/core/compiler/timings.rs:397:38 clippy::cast_possible_truncation "casting `f64` to `u32` may truncate the value"
+cargo-0.49.0/src/cargo/core/compiler/timings.rs:397:38 clippy::cast_sign_loss "casting `f64` to `u32` may lose the sign of the value"
+cargo-0.49.0/src/cargo/core/compiler/timings.rs:484:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/core/compiler/timings.rs:605:38 clippy::doc_markdown "you should put `rmeta_time` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/compiler/timings.rs:605:50 clippy::doc_markdown "you should put `codegen_time` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/compiler/timings.rs:641:26 clippy::non_ascii_literal "literal non-ASCII character detected"
+cargo-0.49.0/src/cargo/core/compiler/unit.rs:100:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/compiler/unit.rs:151:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/core/compiler/unit.rs:161:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/compiler/unit.rs:35:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/core/compiler/unit_dependencies.rs:154:29 clippy::doc_markdown "you should put `state.unit_dependencies` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/compiler/unit_dependencies.rs:213:1 clippy::too_many_lines "this function has too many lines (110/100)"
+cargo-0.49.0/src/cargo/core/compiler/unit_dependencies.rs:52:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/compiler/unit_dependencies.rs:52:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo-0.49.0/src/cargo/core/compiler/unit_graph.rs:65:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/compiler/unit_graph.rs:65:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo-0.49.0/src/cargo/core/dependency.rs:157:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/dependency.rs:182:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/dependency.rs:203:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/dependency.rs:224:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/dependency.rs:23:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+cargo-0.49.0/src/cargo/core/dependency.rs:248:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/dependency.rs:270:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/dependency.rs:274:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/dependency.rs:278:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/dependency.rs:287:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/dependency.rs:291:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/dependency.rs:305:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/dependency.rs:311:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/dependency.rs:319:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/dependency.rs:337:75 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/dependency.rs:397:56 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/dependency.rs:403:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/dependency.rs:408:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/dependency.rs:415:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/dependency.rs:419:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/dependency.rs:424:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/dependency.rs:428:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/dependency.rs:433:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/dependency.rs:438:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/dependency.rs:443:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/dependency.rs:449:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/dependency.rs:450:9 clippy::if_not_else "unnecessary `!=` operation"
+cargo-0.49.0/src/cargo/core/features.rs:119:17 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/features.rs:229:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/features.rs:274:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/features.rs:278:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/features.rs:306:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/features.rs:338:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+cargo-0.49.0/src/cargo/core/features.rs:362:25 clippy::option_option "consider using `Option<T>` instead of `Option<Option<T>>` or a custom enum if you need to distinguish all 3 cases"
+cargo-0.49.0/src/cargo/core/features.rs:380:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/features.rs:401:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/core/features.rs:409:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/core/features.rs:412:45 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/features.rs:416:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/core/features.rs:419:45 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/features.rs:424:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/core/features.rs:431:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/core/features.rs:477:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/features.rs:509:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/features.rs:518:5 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
+cargo-0.49.0/src/cargo/core/features.rs:542:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/features.rs:543:37 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/features.rs:547:60 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/features.rs:556:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo-0.49.0/src/cargo/core/features.rs:563:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo-0.49.0/src/cargo/core/manifest.rs:116:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+cargo-0.49.0/src/cargo/core/manifest.rs:118:58 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/manifest.rs:130:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+cargo-0.49.0/src/cargo/core/manifest.rs:143:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:159:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:162:34 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/manifest.rs:169:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:17:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/cargo/core/manifest.rs:189:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+cargo-0.49.0/src/cargo/core/manifest.rs:215:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:222:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:22:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo-0.49.0/src/cargo/core/manifest.rs:360:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:407:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:410:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:413:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:416:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:419:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:422:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:425:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:431:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:438:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:444:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:447:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:450:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:453:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:456:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:459:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:462:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:466:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:470:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:477:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:481:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:488:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/manifest.rs:512:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:516:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:520:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:524:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:528:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:538:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:557:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:561:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:565:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:569:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:577:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:581:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:588:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:617:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:632:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:648:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:659:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:66:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo-0.49.0/src/cargo/core/manifest.rs:670:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:693:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:708:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:723:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:726:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:729:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:735:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:738:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:741:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:744:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:747:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:751:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:754:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:757:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:760:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:763:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:767:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:776:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:780:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:787:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:798:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:800:56 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/manifest.rs:805:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:809:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:818:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:823:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:828:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:831:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:834:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:839:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:85:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/core/manifest.rs:888:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/manifest.rs:936:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/package.rs:1075:28 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/package.rs:160:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/package.rs:170:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/package.rs:174:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/package.rs:182:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/package.rs:186:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/package.rs:190:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/package.rs:194:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/package.rs:198:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/package.rs:202:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/package.rs:206:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/package.rs:210:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/package.rs:217:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/package.rs:221:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/package.rs:222:35 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/package.rs:226:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/package.rs:227:35 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/package.rs:230:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/package.rs:239:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/package.rs:249:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/package.rs:287:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/core/package.rs:385:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/package.rs:421:5 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
+cargo-0.49.0/src/cargo/core/package.rs:425:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/package.rs:452:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/package.rs:453:60 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/package.rs:459:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/package.rs:473:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/package.rs:587:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/package.rs:588:9 clippy::needless_question_mark "Question mark operator is useless here"
+cargo-0.49.0/src/cargo/core/package.rs:682:46 clippy::cast_possible_truncation "casting `f64` to `u64` may truncate the value"
+cargo-0.49.0/src/cargo/core/package.rs:682:46 clippy::cast_sign_loss "casting `f64` to `u64` may lose the sign of the value"
+cargo-0.49.0/src/cargo/core/package.rs:682:63 clippy::cast_possible_truncation "casting `f64` to `u64` may truncate the value"
+cargo-0.49.0/src/cargo/core/package.rs:682:63 clippy::cast_sign_loss "casting `f64` to `u64` may lose the sign of the value"
+cargo-0.49.0/src/cargo/core/package.rs:731:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/package.rs:790:13 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+cargo-0.49.0/src/cargo/core/package.rs:988:9 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+cargo-0.49.0/src/cargo/core/package_id.rs:115:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/package_id.rs:124:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/package_id.rs:139:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/package_id.rs:142:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/package_id.rs:145:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/package_id.rs:149:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/package_id.rs:157:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/package_id.rs:161:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/package_id.rs:169:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/package_id.rs:174:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/core/package_id_spec.rs:101:39 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/package_id_spec.rs:143:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/package_id_spec.rs:147:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/package_id_spec.rs:151:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/package_id_spec.rs:160:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/package_id_spec.rs:179:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/package_id_spec.rs:212:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/core/package_id_spec.rs:231:9 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+cargo-0.49.0/src/cargo/core/package_id_spec.rs:51:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/package_id_spec.rs:77:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/package_id_spec.rs:88:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/profiles.rs:1004:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/profiles.rs:1014:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/profiles.rs:1018:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/profiles.rs:1028:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/profiles.rs:106:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/core/profiles.rs:143:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+cargo-0.49.0/src/cargo/core/profiles.rs:286:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/profiles.rs:294:40 clippy::if_not_else "unnecessary boolean `not` operation"
+cargo-0.49.0/src/cargo/core/profiles.rs:30:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/profiles.rs:342:25 clippy::shadow_unrelated "`maker` is being shadowed"
+cargo-0.49.0/src/cargo/core/profiles.rs:370:41 clippy::unused_self "unused `self` argument"
+cargo-0.49.0/src/cargo/core/profiles.rs:370:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/profiles.rs:372:9 clippy::field_reassign_with_default "field assignment outside of initializer for an instance created with Default::default()"
+cargo-0.49.0/src/cargo/core/profiles.rs:382:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/profiles.rs:383:28 clippy::if_not_else "unnecessary boolean `not` operation"
+cargo-0.49.0/src/cargo/core/profiles.rs:397:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/profiles.rs:405:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/profiles.rs:607:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+cargo-0.49.0/src/cargo/core/profiles.rs:909:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/profiles.rs:923:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/profiles.rs:934:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/profiles.rs:987:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/registry.rs:111:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/registry.rs:127:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/registry.rs:168:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/registry.rs:19:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/registry.rs:240:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/registry.rs:26:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/registry.rs:344:49 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/registry.rs:369:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/registry.rs:424:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/registry.rs:49:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo-0.49.0/src/cargo/core/registry.rs:520:17 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+cargo-0.49.0/src/cargo/core/registry.rs:763:53 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/registry.rs:765:53 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/registry.rs:807:14 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/registry.rs:814:53 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/resolver/conflict_cache.rs:197:29 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/resolver/conflict_cache.rs:41:38 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
+cargo-0.49.0/src/cargo/core/resolver/context.rs:274:53 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/resolver/context.rs:42:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/core/resolver/context.rs:74:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/resolver/encode.rs:156:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/resolver/encode.rs:156:5 clippy::too_many_lines "this function has too many lines (164/100)"
+cargo-0.49.0/src/cargo/core/resolver/encode.rs:339:17 clippy::match_wildcard_for_single_variants "wildcard match will miss any future added variants"
+cargo-0.49.0/src/cargo/core/resolver/encode.rs:438:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/core/resolver/encode.rs:449:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/core/resolver/encode.rs:529:34 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/resolver/encode.rs:602:59 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/resolver/encode.rs:623:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/core/resolver/encode.rs:652:27 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+cargo-0.49.0/src/cargo/core/resolver/encode.rs:674:51 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/resolver/errors.rs:103:22 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/resolver/errors.rs:104:22 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/resolver/errors.rs:206:9 clippy::if_not_else "unnecessary boolean `not` operation"
+cargo-0.49.0/src/cargo/core/resolver/errors.rs:257:45 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/resolver/errors.rs:27:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/resolver/errors.rs:305:17 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
+cargo-0.49.0/src/cargo/core/resolver/errors.rs:70:1 clippy::too_many_lines "this function has too many lines (207/100)"
+cargo-0.49.0/src/cargo/core/resolver/features.rs:104:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/core/resolver/features.rs:111:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/resolver/features.rs:162:56 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/resolver/features.rs:179:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo-0.49.0/src/cargo/core/resolver/features.rs:186:23 clippy::doc_markdown "you should put `RequestedFeatures` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/resolver/features.rs:187:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/resolver/features.rs:199:23 clippy::doc_markdown "you should put `RequestedFeatures` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/resolver/features.rs:200:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/resolver/features.rs:221:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/resolver/features.rs:231:21 clippy::doc_markdown "you should put `pkg_id/is_build` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/resolver/features.rs:233:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/resolver/features.rs:247:58 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/resolver/features.rs:278:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/resolver/features.rs:394:27 clippy::doc_markdown "you should put `FeatureValue` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/resolver/features.rs:460:19 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+cargo-0.49.0/src/cargo/core/resolver/features.rs:480:24 clippy::doc_markdown "you should put `FeatureValues` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/resolver/features.rs:496:24 clippy::doc_markdown "you should put `FeatureValues` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/resolver/features.rs:58:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo-0.49.0/src/cargo/core/resolver/features.rs:67:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+cargo-0.49.0/src/cargo/core/resolver/mod.rs:1017:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/core/resolver/mod.rs:1045:57 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/resolver/mod.rs:122:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/resolver/mod.rs:142:44 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/resolver/mod.rs:180:1 clippy::too_many_lines "this function has too many lines (225/100)"
+cargo-0.49.0/src/cargo/core/resolver/mod.rs:311:17 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+cargo-0.49.0/src/cargo/core/resolver/mod.rs:421:52 clippy::filter_map_next "called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find_map(..)` instead."
+cargo-0.49.0/src/cargo/core/resolver/mod.rs:457:69 clippy::filter_map_next "called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find_map(..)` instead."
+cargo-0.49.0/src/cargo/core/resolver/mod.rs:470:37 clippy::similar_names "binding's name is too similar to existing binding"
+cargo-0.49.0/src/cargo/core/resolver/mod.rs:607:11 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+cargo-0.49.0/src/cargo/core/resolver/mod.rs:631:21 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+cargo-0.49.0/src/cargo/core/resolver/mod.rs:942:15 clippy::if_not_else "unnecessary boolean `not` operation"
+cargo-0.49.0/src/cargo/core/resolver/mod.rs:988:20 clippy::redundant_else "redundant else block"
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:120:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:132:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:199:24 clippy::redundant_else "redundant else block"
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:235:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:239:5 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:255:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:259:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:263:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:269:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:273:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:274:9 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:280:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:284:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:288:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:292:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:296:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:300:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:315:13 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:354:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:362:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:60:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/core/resolver/resolve.rs:76:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/resolver/types.rs:111:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/resolver/types.rs:121:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/resolver/types.rs:141:19 clippy::doc_markdown "you should put `ResolveOpts` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/resolver/types.rs:142:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/resolver/types.rs:149:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/resolver/types.rs:181:9 clippy::map_unwrap_or "called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead"
+cargo-0.49.0/src/cargo/core/resolver/types.rs:187:5 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
+cargo-0.49.0/src/cargo/core/resolver/types.rs:261:5 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
+cargo-0.49.0/src/cargo/core/shell.rs:113:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/shell.rs:130:9 clippy::single_match_else "you seem to be trying to use `match` for an equality check. Consider using `if`"
+cargo-0.49.0/src/cargo/core/shell.rs:148:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/shell.rs:153:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/shell.rs:163:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/shell.rs:18:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/shell.rs:198:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/shell.rs:206:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/shell.rs:214:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/shell.rs:228:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/shell.rs:239:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/shell.rs:250:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/shell.rs:259:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/shell.rs:267:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/shell.rs:26:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/shell.rs:277:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/shell.rs:282:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/shell.rs:314:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/shell.rs:322:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/shell.rs:330:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/shell.rs:98:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/source/mod.rs:103:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/source/mod.rs:247:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/core/source/mod.rs:261:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/source/mod.rs:268:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/source/mod.rs:273:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/source/mod.rs:291:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/source/mod.rs:302:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/source/mod.rs:307:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/source/mod.rs:31:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/source/mod.rs:37:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/source/mod.rs:39:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/source/mod.rs:47:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/source/mod.rs:50:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/source/mod.rs:52:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/source/mod.rs:63:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/source/mod.rs:74:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/source/mod.rs:83:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:107:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:128:50 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:147:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:156:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:162:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:166:19 clippy::doc_markdown "you should put `SourceId` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:167:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:171:19 clippy::doc_markdown "you should put `SourceId` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:172:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:178:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:187:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:18:74 clippy::default_trait_access "calling `std::sync::Mutex::default()` is more clear than this expression"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:195:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:207:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:213:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:217:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:225:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:228:16 clippy::option_if_let_else "use Option::map_or_else instead of an if let/else"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:236:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:241:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:252:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:257:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:262:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:305:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:310:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:318:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:326:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:355:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:393:61 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:394:42 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:395:42 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:397:71 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:397:71 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:398:47 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:398:47 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:399:47 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:399:47 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:401:63 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:401:63 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:401:63 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:402:43 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:402:43 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:402:43 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:403:43 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:403:43 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:403:43 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:406:21 clippy::enum_glob_use "usage of wildcard import for enum variants"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:412:41 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:413:36 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:414:36 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:420:47 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:420:47 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:512:17 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:513:17 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:517:17 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:518:17 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:525:17 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:526:17 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:530:17 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:531:17 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:535:33 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:536:37 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:537:42 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:538:38 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:548:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/core/source/source_id.rs:597:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/summary.rs:103:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/summary.rs:123:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/summary.rs:150:1 clippy::too_many_lines "this function has too many lines (141/100)"
+cargo-0.49.0/src/cargo/core/summary.rs:158:9 clippy::enum_glob_use "usage of wildcard import for enum variants"
+cargo-0.49.0/src/cargo/core/summary.rs:181:21 clippy::if_not_else "unnecessary boolean `not` operation"
+cargo-0.49.0/src/cargo/core/summary.rs:192:28 clippy::redundant_else "redundant else block"
+cargo-0.49.0/src/cargo/core/summary.rs:258:32 clippy::redundant_else "redundant else block"
+cargo-0.49.0/src/cargo/core/summary.rs:281:28 clippy::redundant_else "redundant else block"
+cargo-0.49.0/src/cargo/core/summary.rs:303:28 clippy::redundant_else "redundant else block"
+cargo-0.49.0/src/cargo/core/summary.rs:321:51 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/core/summary.rs:344:5 clippy::doc_markdown "you should put `FeatureValue` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/summary.rs:350:85 clippy::doc_markdown "you should put `FeatureValue` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/summary.rs:36:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/summary.rs:378:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/summary.rs:386:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/summary.rs:387:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+cargo-0.49.0/src/cargo/core/summary.rs:407:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+cargo-0.49.0/src/cargo/core/summary.rs:69:34 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/summary.rs:75:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/summary.rs:78:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/summary.rs:81:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/summary.rs:84:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/summary.rs:87:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/summary.rs:90:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/summary.rs:93:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/summary.rs:96:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/summary.rs:99:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/workspace.rs:1056:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+cargo-0.49.0/src/cargo/core/workspace.rs:113:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/core/workspace.rs:1157:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/core/workspace.rs:128:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/core/workspace.rs:150:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/workspace.rs:159:16 clippy::redundant_else "redundant else block"
+cargo-0.49.0/src/cargo/core/workspace.rs:197:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/workspace.rs:225:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/workspace.rs:255:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/workspace.rs:267:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/workspace.rs:329:37 clippy::doc_markdown "you should put `VirtualManifest` between ticks in the documentation"
+cargo-0.49.0/src/cargo/core/workspace.rs:410:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/workspace.rs:440:9 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+cargo-0.49.0/src/cargo/core/workspace.rs:511:32 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+cargo-0.49.0/src/cargo/core/workspace.rs:561:25 clippy::non_ascii_literal "literal non-ASCII character detected"
+cargo-0.49.0/src/cargo/core/workspace.rs:613:13 clippy::filter_map "called `filter_map(..).map(..)` on an `Iterator`"
+cargo-0.49.0/src/cargo/core/workspace.rs:615:22 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/core/workspace.rs:762:27 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+cargo-0.49.0/src/cargo/core/workspace.rs:784:17 clippy::if_not_else "unnecessary boolean `not` operation"
+cargo-0.49.0/src/cargo/core/workspace.rs:849:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/workspace.rs:893:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/core/workspace.rs:906:24 clippy::redundant_else "redundant else block"
+cargo-0.49.0/src/cargo/core/workspace.rs:932:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/lib.rs:177:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/lib.rs:180:36 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/lib.rs:180:36 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/lib.rs:180:36 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/lib.rs:180:36 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/lib.rs:180:36 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/lib.rs:1:null clippy::cargo_common_metadata "package `cargo` is missing `package.categories` metadata"
+cargo-0.49.0/src/cargo/lib.rs:1:null clippy::cargo_common_metadata "package `cargo` is missing `package.keywords` metadata"
+cargo-0.49.0/src/cargo/lib.rs:1:null clippy::multiple_crate_versions "multiple versions for dependency `crossbeam-utils`: 0.6.6, 0.7.2"
+cargo-0.49.0/src/cargo/lib.rs:1:null clippy::multiple_crate_versions "multiple versions for dependency `hex`: 0.3.2, 0.4.0"
+cargo-0.49.0/src/cargo/lib.rs:1:null clippy::multiple_crate_versions "multiple versions for dependency `humantime`: 1.3.0, 2.0.0"
+cargo-0.49.0/src/cargo/ops/cargo_clean.rs:205:23 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/ops/cargo_clean.rs:27:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/cargo_clean.rs:27:1 clippy::too_many_lines "this function has too many lines (120/100)"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:1078:14 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:109:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:119:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:1227:17 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:127:35 clippy::from_iter_instead_of_collect "usage of `FromIterator::from_iter`"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:173:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:205:36 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:242:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:249:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:258:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:267:16 clippy::needless_question_mark "Question mark operator is useless here"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:275:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:275:1 clippy::too_many_lines "this function has too many lines (219/100)"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:468:9 clippy::default_trait_access "calling `std::collections::HashMap::default()` is more clear than this expression"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:548:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:556:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:574:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:583:21 clippy::doc_markdown "you should put `CompileFilter` between ticks in the documentation"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:584:5 clippy::fn_params_excessive_bools "more than 3 bools in function parameters"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:584:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:592:9 clippy::similar_names "binding's name is too similar to existing binding"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:593:9 clippy::similar_names "binding's name is too similar to existing binding"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:607:13 clippy::similar_names "binding's name is too similar to existing binding"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:612:21 clippy::doc_markdown "you should put `CompileFilter` between ticks in the documentation"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:613:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:618:9 clippy::similar_names "binding's name is too similar to existing binding"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:641:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:652:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:655:50 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:673:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:692:49 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:703:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:729:1 clippy::too_many_lines "this function has too many lines (205/100)"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:82:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/cargo_compile.rs:874:69 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/ops/cargo_doc.rs:20:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/cargo_fetch.rs:15:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/cargo_fetch.rs:27:46 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/ops/cargo_generate_lockfile.rs:160:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/ops/cargo_generate_lockfile.rs:175:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/ops/cargo_generate_lockfile.rs:22:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/cargo_generate_lockfile.rs:37:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/cargo_generate_lockfile.rs:37:1 clippy::too_many_lines "this function has too many lines (171/100)"
+cargo-0.49.0/src/cargo/ops/cargo_install.rs:13:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/cargo/ops/cargo_install.rs:148:1 clippy::fn_params_excessive_bools "more than 3 bools in function parameters"
+cargo-0.49.0/src/cargo/ops/cargo_install.rs:148:1 clippy::too_many_lines "this function has too many lines (316/100)"
+cargo-0.49.0/src/cargo/ops/cargo_install.rs:178:24 clippy::collapsible_else_if "this `else { if .. }` block can be collapsed"
+cargo-0.49.0/src/cargo/ops/cargo_install.rs:202:17 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/ops/cargo_install.rs:236:16 clippy::collapsible_else_if "this `else { if .. }` block can be collapsed"
+cargo-0.49.0/src/cargo/ops/cargo_install.rs:312:64 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/ops/cargo_install.rs:32:13 clippy::let_underscore_drop "non-binding `let` on a type that implements `Drop`"
+cargo-0.49.0/src/cargo/ops/cargo_install.rs:339:12 clippy::collapsible_else_if "this `else { if .. }` block can be collapsed"
+cargo-0.49.0/src/cargo/ops/cargo_install.rs:37:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/cargo_install.rs:454:22 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/ops/cargo_install.rs:483:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/ops/cargo_install.rs:683:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/cargo_new.rs:101:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/cargo_new.rs:245:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/ops/cargo_new.rs:251:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/ops/cargo_new.rs:367:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/cargo_new.rs:405:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/cargo_new.rs:489:5 clippy::doc_markdown "you should put `IgnoreList` between ticks in the documentation"
+cargo-0.49.0/src/cargo/ops/cargo_new.rs:525:47 clippy::doc_markdown "you should put `IgnoreList` between ticks in the documentation"
+cargo-0.49.0/src/cargo/ops/cargo_new.rs:525:9 clippy::doc_markdown "you should put `format_existing` between ticks in the documentation"
+cargo-0.49.0/src/cargo/ops/cargo_new.rs:572:34 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/ops/cargo_new.rs:623:1 clippy::too_many_lines "this function has too many lines (130/100)"
+cargo-0.49.0/src/cargo/ops/cargo_new.rs:781:5 clippy::filter_map_next "called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find_map(..)` instead."
+cargo-0.49.0/src/cargo/ops/cargo_new.rs:800:16 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+cargo-0.49.0/src/cargo/ops/cargo_output_metadata.rs:163:36 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/ops/cargo_output_metadata.rs:27:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/cargo_output_metadata.rs:45:45 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/ops/cargo_package.rs:144:1 clippy::too_many_lines "this function has too many lines (112/100)"
+cargo-0.49.0/src/cargo/ops/cargo_package.rs:207:13 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+cargo-0.49.0/src/cargo/ops/cargo_package.rs:25:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+cargo-0.49.0/src/cargo/ops/cargo_package.rs:307:54 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/ops/cargo_package.rs:394:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/ops/cargo_package.rs:425:61 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/ops/cargo_package.rs:459:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/ops/cargo_package.rs:66:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/cargo_package.rs:93:20 clippy::if_not_else "unnecessary boolean `not` operation"
+cargo-0.49.0/src/cargo/ops/cargo_pkgid.rs:5:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/cargo_read_manifest.rs:14:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/cargo_read_manifest.rs:171:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/ops/cargo_read_manifest.rs:37:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/cargo_read_manifest.rs:57:49 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/ops/cargo_read_manifest.rs:69:37 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/ops/cargo_run.rs:25:24 clippy::if_not_else "unnecessary boolean `not` operation"
+cargo-0.49.0/src/cargo/ops/cargo_run.rs:35:9 clippy::if_not_else "unnecessary boolean `not` operation"
+cargo-0.49.0/src/cargo/ops/cargo_run.rs:37:16 clippy::redundant_else "redundant else block"
+cargo-0.49.0/src/cargo/ops/cargo_run.rs:53:9 clippy::if_not_else "unnecessary boolean `not` operation"
+cargo-0.49.0/src/cargo/ops/cargo_run.rs:65:16 clippy::redundant_else "redundant else block"
+cargo-0.49.0/src/cargo/ops/cargo_run.rs:9:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/cargo_test.rs:16:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/cargo_test.rs:43:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/cargo_test.rs:84:17 clippy::similar_names "binding's name is too similar to existing binding"
+cargo-0.49.0/src/cargo/ops/cargo_uninstall.rs:14:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/cargo_uninstall.rs:7:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:147:9 clippy::doc_markdown "you should put `PackageId` between ticks in the documentation"
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:233:21 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:244:22 clippy::doc_markdown "you should put `PackageId` between ticks in the documentation"
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:244:63 clippy::doc_markdown "you should put `PackageId` between ticks in the documentation"
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:253:17 clippy::if_not_else "unnecessary boolean `not` operation"
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:370:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:505:8 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:525:10 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:542:27 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:542:5 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:561:20 clippy::redundant_else "redundant else block"
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:613:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:645:41 clippy::doc_markdown "you should put `BTreeSet` between ticks in the documentation"
+cargo-0.49.0/src/cargo/ops/common_for_install_and_uninstall.rs:92:19 clippy::doc_markdown "you should put `InstallTracker` between ticks in the documentation"
+cargo-0.49.0/src/cargo/ops/fix.rs:200:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/fix.rs:200:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/ops/fix.rs:424:20 clippy::map_unwrap_or "called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead"
+cargo-0.49.0/src/cargo/ops/fix.rs:455:13 clippy::similar_names "binding's name is too similar to existing binding"
+cargo-0.49.0/src/cargo/ops/fix.rs:506:17 clippy::similar_names "binding's name is too similar to existing binding"
+cargo-0.49.0/src/cargo/ops/fix.rs:608:9 clippy::field_reassign_with_default "field assignment outside of initializer for an instance created with Default::default()"
+cargo-0.49.0/src/cargo/ops/fix.rs:612:42 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/ops/fix.rs:619:48 clippy::manual_strip "stripping a prefix manually"
+cargo-0.49.0/src/cargo/ops/fix.rs:66:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/ops/fix.rs:66:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+cargo-0.49.0/src/cargo/ops/fix.rs:708:18 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/ops/fix.rs:77:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/lockfile.rs:154:13 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
+cargo-0.49.0/src/cargo/ops/lockfile.rs:217:9 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
+cargo-0.49.0/src/cargo/ops/lockfile.rs:30:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/lockfile.rs:35:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/lockfile.rs:35:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo-0.49.0/src/cargo/ops/lockfile.rs:87:1 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+cargo-0.49.0/src/cargo/ops/lockfile.rs:8:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/lockfile.rs:8:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo-0.49.0/src/cargo/ops/registry.rs:150:21 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/ops/registry.rs:188:1 clippy::too_many_lines "this function has too many lines (130/100)"
+cargo-0.49.0/src/cargo/ops/registry.rs:212:32 clippy::if_not_else "unnecessary `!=` operation"
+cargo-0.49.0/src/cargo/ops/registry.rs:222:53 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/ops/registry.rs:224:44 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/ops/registry.rs:31:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/ops/registry.rs:346:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/registry.rs:346:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/ops/registry.rs:351:26 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+cargo-0.49.0/src/cargo/ops/registry.rs:385:12 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+cargo-0.49.0/src/cargo/ops/registry.rs:386:15 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+cargo-0.49.0/src/cargo/ops/registry.rs:38:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+cargo-0.49.0/src/cargo/ops/registry.rs:477:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/registry.rs:483:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/registry.rs:503:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/registry.rs:505:38 clippy::default_trait_access "calling `util::config::CargoHttpConfig::default()` is more clear than this expression"
+cargo-0.49.0/src/cargo/ops/registry.rs:510:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/registry.rs:529:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/ops/registry.rs:53:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/registry.rs:573:22 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/ops/registry.rs:608:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/registry.rs:621:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/registry.rs:671:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/registry.rs:671:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/ops/registry.rs:674:10 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+cargo-0.49.0/src/cargo/ops/registry.rs:678:17 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+cargo-0.49.0/src/cargo/ops/registry.rs:730:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/registry.rs:731:16 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+cargo-0.49.0/src/cargo/ops/registry.rs:785:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/registry.rs:794:16 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+cargo-0.49.0/src/cargo/ops/registry.rs:828:14 clippy::doc_markdown "you should put `SourceId` between ticks in the documentation"
+cargo-0.49.0/src/cargo/ops/registry.rs:848:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/resolve.rs:199:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/resolve.rs:199:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/ops/resolve.rs:199:1 clippy::too_many_lines "this function has too many lines (137/100)"
+cargo-0.49.0/src/cargo/ops/resolve.rs:241:28 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+cargo-0.49.0/src/cargo/ops/resolve.rs:28:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo-0.49.0/src/cargo/ops/resolve.rs:384:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/resolve.rs:417:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/resolve.rs:589:9 clippy::shadow_unrelated "`keep` is being shadowed"
+cargo-0.49.0/src/cargo/ops/resolve.rs:58:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/resolve.rs:58:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/ops/resolve.rs:602:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/ops/resolve.rs:75:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/resolve.rs:75:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/ops/tree/graph.rs:129:26 clippy::doc_markdown "you should put `PackageIds` between ticks in the documentation"
+cargo-0.49.0/src/cargo/ops/tree/graph.rs:152:15 clippy::match_on_vec_items "indexing into a vector may panic"
+cargo-0.49.0/src/cargo/ops/tree/graph.rs:173:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/ops/tree/graph.rs:234:46 clippy::filter_map "called `filter(..).flat_map(..)` on an `Iterator`"
+cargo-0.49.0/src/cargo/ops/tree/graph.rs:328:44 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/ops/tree/graph.rs:330:50 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/ops/tree/graph.rs:563:35 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+cargo-0.49.0/src/cargo/ops/tree/mod.rs:112:11 clippy::non_ascii_literal "literal non-ASCII character detected"
+cargo-0.49.0/src/cargo/ops/tree/mod.rs:113:10 clippy::non_ascii_literal "literal non-ASCII character detected"
+cargo-0.49.0/src/cargo/ops/tree/mod.rs:114:10 clippy::non_ascii_literal "literal non-ASCII character detected"
+cargo-0.49.0/src/cargo/ops/tree/mod.rs:115:12 clippy::non_ascii_literal "literal non-ASCII character detected"
+cargo-0.49.0/src/cargo/ops/tree/mod.rs:126:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/tree/mod.rs:21:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/ops/tree/mod.rs:21:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+cargo-0.49.0/src/cargo/ops/tree/mod.rs:360:30 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/ops/tree/mod.rs:58:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/ops/vendor.rs:14:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/ops/vendor.rs:21:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/ops/vendor.rs:314:34 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/ops/vendor.rs:320:29 clippy::case_sensitive_file_extension_comparisons "case-sensitive file extension comparison"
+cargo-0.49.0/src/cargo/ops/vendor.rs:320:60 clippy::case_sensitive_file_extension_comparisons "case-sensitive file extension comparison"
+cargo-0.49.0/src/cargo/ops/vendor.rs:324:13 clippy::match_wildcard_for_single_variants "wildcard match will miss any future added variants"
+cargo-0.49.0/src/cargo/ops/vendor.rs:70:1 clippy::too_many_lines "this function has too many lines (175/100)"
+cargo-0.49.0/src/cargo/sources/config.rs:102:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/sources/config.rs:111:28 clippy::needless_question_mark "Question mark operator is useless here"
+cargo-0.49.0/src/cargo/sources/config.rs:133:48 clippy::needless_question_mark "Question mark operator is useless here"
+cargo-0.49.0/src/cargo/sources/config.rs:135:67 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/sources/config.rs:206:36 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+cargo-0.49.0/src/cargo/sources/config.rs:282:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/sources/config.rs:70:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/sources/config.rs:81:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/sources/config.rs:97:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/sources/directory.rs:14:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/sources/directory.rs:90:56 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/sources/git/source.rs:14:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo-0.49.0/src/cargo/sources/git/source.rs:25:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/sources/git/source.rs:49:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/sources/git/source.rs:53:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/sources/git/source.rs:69:20 clippy::comparison_to_empty "comparison to empty slice"
+cargo-0.49.0/src/cargo/sources/git/utils.rs:1025:19 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+cargo-0.49.0/src/cargo/sources/git/utils.rs:1157:36 clippy::case_sensitive_file_extension_comparisons "case-sensitive file extension comparison"
+cargo-0.49.0/src/cargo/sources/git/utils.rs:1158:9 clippy::manual_strip "stripping a suffix manually"
+cargo-0.49.0/src/cargo/sources/git/utils.rs:134:12 clippy::upper_case_acronyms "name `GitShortID` contains a capitalized acronym"
+cargo-0.49.0/src/cargo/sources/git/utils.rs:176:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/sources/git/utils.rs:180:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/sources/git/utils.rs:184:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/sources/git/utils.rs:188:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/sources/git/utils.rs:242:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/sources/git/utils.rs:253:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/sources/git/utils.rs:262:13 clippy::if_not_else "unnecessary boolean `not` operation"
+cargo-0.49.0/src/cargo/sources/git/utils.rs:289:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/sources/git/utils.rs:294:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/sources/git/utils.rs:298:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/sources/git/utils.rs:308:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/sources/git/utils.rs:472:9 clippy::let_underscore_drop "non-binding `let` on a type that implements `Drop`"
+cargo-0.49.0/src/cargo/sources/git/utils.rs:489:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/sources/git/utils.rs:503:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/sources/git/utils.rs:528:28 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+cargo-0.49.0/src/cargo/sources/git/utils.rs:537:21 clippy::let_underscore_drop "non-binding `let` on a type that implements `Drop`"
+cargo-0.49.0/src/cargo/sources/git/utils.rs:588:1 clippy::too_many_lines "this function has too many lines (135/100)"
+cargo-0.49.0/src/cargo/sources/git/utils.rs:692:9 clippy::vec_init_then_push "calls to `push` immediately after creation"
+cargo-0.49.0/src/cargo/sources/git/utils.rs:758:9 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
+cargo-0.49.0/src/cargo/sources/git/utils.rs:858:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/sources/path.rs:129:44 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/sources/path.rs:143:44 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/sources/path.rs:15:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/sources/path.rs:282:50 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/sources/path.rs:313:21 clippy::similar_names "binding's name is too similar to existing binding"
+cargo-0.49.0/src/cargo/sources/path.rs:314:21 clippy::similar_names "binding's name is too similar to existing binding"
+cargo-0.49.0/src/cargo/sources/path.rs:319:21 clippy::similar_names "binding's name is too similar to existing binding"
+cargo-0.49.0/src/cargo/sources/path.rs:339:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/sources/path.rs:339:9 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+cargo-0.49.0/src/cargo/sources/path.rs:380:9 clippy::unused_self "unused `self` argument"
+cargo-0.49.0/src/cargo/sources/path.rs:419:50 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/sources/path.rs:429:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/sources/path.rs:460:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/sources/path.rs:473:43 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/sources/path.rs:482:43 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/sources/path.rs:63:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/sources/path.rs:77:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/sources/path.rs:98:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/sources/registry/index.rs:117:23 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo-0.49.0/src/cargo/sources/registry/index.rs:121:70 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo-0.49.0/src/cargo/sources/registry/index.rs:167:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo-0.49.0/src/cargo/sources/registry/index.rs:215:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/sources/registry/index.rs:324:23 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/sources/registry/index.rs:468:40 clippy::doc_markdown "you should put `SourceId` between ticks in the documentation"
+cargo-0.49.0/src/cargo/sources/registry/index.rs:590:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/sources/registry/index.rs:648:17 clippy::similar_names "binding's name is too similar to existing binding"
+cargo-0.49.0/src/cargo/sources/registry/index.rs:736:1 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
+cargo-0.49.0/src/cargo/sources/registry/index.rs:95:37 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+cargo-0.49.0/src/cargo/sources/registry/local.rs:12:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/sources/registry/mod.rs:192:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/sources/registry/mod.rs:203:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/sources/registry/mod.rs:229:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/sources/registry/mod.rs:372:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/sources/registry/mod.rs:373:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/sources/registry/mod.rs:375:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/sources/registry/mod.rs:381:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/sources/registry/mod.rs:382:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/sources/registry/mod.rs:383:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/sources/registry/mod.rs:384:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/sources/registry/mod.rs:452:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/sources/registry/mod.rs:582:20 clippy::redundant_else "redundant else block"
+cargo-0.49.0/src/cargo/sources/registry/mod.rs:621:9 clippy::if_not_else "unnecessary `!=` operation"
+cargo-0.49.0/src/cargo/sources/registry/remote.rs:139:17 clippy::unused_self "unused `self` argument"
+cargo-0.49.0/src/cargo/sources/registry/remote.rs:32:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/sources/registry/remote.rs:72:13 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+cargo-0.49.0/src/cargo/sources/replaced.rs:12:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/sources/replaced.rs:5:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/util/canonical_url.rs:19:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/canonical_url.rs:50:41 clippy::case_sensitive_file_extension_comparisons "case-sensitive file extension comparison"
+cargo-0.49.0/src/cargo/util/canonical_url.rs:65:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/command_prelude.rs:218:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/command_prelude.rs:222:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/command_prelude.rs:234:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/command_prelude.rs:249:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/command_prelude.rs:264:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/command_prelude.rs:279:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/command_prelude.rs:298:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/command_prelude.rs:320:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/command_prelude.rs:328:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/command_prelude.rs:352:13 clippy::if_not_else "unnecessary boolean `not` operation"
+cargo-0.49.0/src/cargo/util/command_prelude.rs:363:13 clippy::if_not_else "unnecessary boolean `not` operation"
+cargo-0.49.0/src/cargo/util/command_prelude.rs:378:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/command_prelude.rs:387:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/command_prelude.rs:387:5 clippy::too_many_lines "this function has too many lines (104/100)"
+cargo-0.49.0/src/cargo/util/command_prelude.rs:39:20 clippy::doc_markdown "you should put `arg_package_spec` between ticks in the documentation"
+cargo-0.49.0/src/cargo/util/command_prelude.rs:504:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/command_prelude.rs:516:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/command_prelude.rs:530:40 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/util/command_prelude.rs:531:43 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/util/command_prelude.rs:536:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/command_prelude.rs:556:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/command_prelude.rs:575:49 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/util/command_prelude.rs:580:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/command_prelude.rs:631:18 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/util/command_prelude.rs:638:18 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/util/command_prelude.rs:647:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/command_prelude.rs:651:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/command_prelude.rs:662:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/command_prelude.rs:665:51 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/util/config/de.rs:420:16 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+cargo-0.49.0/src/cargo/util/config/de.rs:46:25 clippy::doc_markdown "you should put `CV::List` between ticks in the documentation"
+cargo-0.49.0/src/cargo/util/config/de.rs:47:24 clippy::doc_markdown "you should put `ConfigSeqAccess` between ticks in the documentation"
+cargo-0.49.0/src/cargo/util/config/de.rs:527:53 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo-0.49.0/src/cargo/util/config/de.rs:530:53 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo-0.49.0/src/cargo/util/config/de.rs:532:68 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo-0.49.0/src/cargo/util/config/key.rs:11:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo-0.49.0/src/cargo/util/config/key.rs:69:9 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
+cargo-0.49.0/src/cargo/util/config/mod.rs:100:71 clippy::doc_markdown "you should put `OptValue` between ticks in the documentation"
+cargo-0.49.0/src/cargo/util/config/mod.rs:100:71 clippy::doc_markdown "you should put `OptValue` between ticks in the documentation"
+cargo-0.49.0/src/cargo/util/config/mod.rs:100:71 clippy::doc_markdown "you should put `OptValue` between ticks in the documentation"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1049:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1064:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1090:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1166:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1179:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1181:33 clippy::needless_question_mark "Question mark operator is useless here"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1184:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1186:33 clippy::needless_question_mark "Question mark operator is useless here"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1189:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1191:33 clippy::needless_question_mark "Question mark operator is useless here"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1203:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1211:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1216:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1225:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1229:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:124:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1254:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1279:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1281:9 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1323:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1339:39 clippy::unused_self "unused `self` argument"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1344:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1420:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1553:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1560:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1567:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1574:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1581:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1588:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1598:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1619:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1623:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1623:64 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1649:9 clippy::option_if_let_else "use Option::map_or_else instead of an if let/else"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1699:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1730:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1757:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1770:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1778:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1804:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1896:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/config/mod.rs:1901:5 clippy::doc_markdown "you should put `StringList` between ticks in the documentation"
+cargo-0.49.0/src/cargo/util/config/mod.rs:214:13 clippy::match_wildcard_for_single_variants "wildcard match will miss any future added variants"
+cargo-0.49.0/src/cargo/util/config/mod.rs:259:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:298:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:311:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:318:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:353:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:401:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:411:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:419:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:431:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:449:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:454:16 clippy::option_if_let_else "use Option::map_or instead of an if let/else"
+cargo-0.49.0/src/cargo/util/config/mod.rs:547:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:556:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:582:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:595:20 clippy::doc_markdown "you should put `StringList` between ticks in the documentation"
+cargo-0.49.0/src/cargo/util/config/mod.rs:689:20 clippy::unused_self "unused `self` argument"
+cargo-0.49.0/src/cargo/util/config/mod.rs:699:5 clippy::fn_params_excessive_bools "more than 3 bools in function parameters"
+cargo-0.49.0/src/cargo/util/config/mod.rs:699:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:719:58 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/util/config/mod.rs:816:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/config/mod.rs:875:36 clippy::similar_names "binding's name is too similar to existing binding"
+cargo-0.49.0/src/cargo/util/config/mod.rs:876:37 clippy::similar_names "binding's name is too similar to existing binding"
+cargo-0.49.0/src/cargo/util/config/path.rs:10:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo-0.49.0/src/cargo/util/config/path.rs:14:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/config/path.rs:48:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/util/config/target.rs:12:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/util/config/target.rs:24:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/util/config/value.rs:29:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo-0.49.0/src/cargo/util/config/value.rs:80:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/config/value.rs:81:9 clippy::match_like_matches_macro "match expression looks like `matches!` macro"
+cargo-0.49.0/src/cargo/util/cpu.rs:11:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/cpu.rs:22:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/cpu.rs:82:25 clippy::cast_precision_loss "casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+cargo-0.49.0/src/cargo/util/cpu.rs:82:9 clippy::cast_precision_loss "casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+cargo-0.49.0/src/cargo/util/dependency_queue.rs:109:27 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/util/dependency_queue.rs:151:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/dependency_queue.rs:156:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/dependency_queue.rs:46:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/dependency_queue.rs:91:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/util/diagnostic_server.rs:218:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo-0.49.0/src/cargo/util/diagnostic_server.rs:230:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/diagnostic_server.rs:242:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/diagnostic_server.rs:58:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/diagnostic_server.rs:96:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/diagnostic_server.rs:96:5 clippy::too_many_lines "this function has too many lines (110/100)"
+cargo-0.49.0/src/cargo/util/diagnostic_server.rs:99:21 clippy::shadow_unrelated "`msg` is being shadowed"
+cargo-0.49.0/src/cargo/util/errors.rs:101:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/errors.rs:143:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/errors.rs:150:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/errors.rs:15:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/errors.rs:237:5 clippy::pub_enum_variant_names "variant name ends with the enum's name"
+cargo-0.49.0/src/cargo/util/errors.rs:245:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/errors.rs:321:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/errors.rs:328:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/errors.rs:356:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/errors.rs:391:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/util/errors.rs:392:13 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/cargo/util/errors.rs:465:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/errors.rs:473:5 clippy::manual_range_contains "manual `RangeInclusive::contains` implementation"
+cargo-0.49.0/src/cargo/util/errors.rs:66:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/flock.rs:115:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/flock.rs:11:5 clippy::wildcard_imports "usage of wildcard import"
+cargo-0.49.0/src/cargo/util/flock.rs:134:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/flock.rs:142:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/flock.rs:150:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/flock.rs:156:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/flock.rs:170:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/flock.rs:192:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/flock.rs:29:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/flock.rs:321:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/util/flock.rs:335:23 clippy::cast_possible_truncation "casting `i64` to `u32` may truncate the value"
+cargo-0.49.0/src/cargo/util/flock.rs:335:23 clippy::cast_sign_loss "casting `i64` to `u32` may lose the sign of the value"
+cargo-0.49.0/src/cargo/util/flock.rs:335:44 clippy::cast_possible_truncation "casting `i64` to `u32` may truncate the value"
+cargo-0.49.0/src/cargo/util/flock.rs:379:35 clippy::match_same_arms "this `match` has identical arm bodies"
+cargo-0.49.0/src/cargo/util/flock.rs:37:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/flock.rs:43:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/flock.rs:52:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/graph.rs:10:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/graph.rs:41:51 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/util/graph.rs:45:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/hasher.rs:12:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/hasher.rs:9:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo-0.49.0/src/cargo/util/hex.rs:10:9 clippy::cast_possible_truncation "casting `u64` to `u8` may truncate the value"
+cargo-0.49.0/src/cargo/util/hex.rs:11:9 clippy::cast_possible_truncation "casting `u64` to `u8` may truncate the value"
+cargo-0.49.0/src/cargo/util/hex.rs:12:9 clippy::cast_possible_truncation "casting `u64` to `u8` may truncate the value"
+cargo-0.49.0/src/cargo/util/hex.rs:13:9 clippy::cast_possible_truncation "casting `u64` to `u8` may truncate the value"
+cargo-0.49.0/src/cargo/util/hex.rs:14:9 clippy::cast_possible_truncation "casting `u64` to `u8` may truncate the value"
+cargo-0.49.0/src/cargo/util/hex.rs:15:9 clippy::cast_possible_truncation "casting `u64` to `u8` may truncate the value"
+cargo-0.49.0/src/cargo/util/hex.rs:25:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/hex.rs:6:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo-0.49.0/src/cargo/util/hex.rs:6:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/hex.rs:8:9 clippy::cast_possible_truncation "casting `u64` to `u8` may truncate the value"
+cargo-0.49.0/src/cargo/util/hex.rs:9:9 clippy::cast_possible_truncation "casting `u64` to `u8` may truncate the value"
+cargo-0.49.0/src/cargo/util/important_paths.rs:23:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/important_paths.rs:6:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/interning.rs:66:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/interning.rs:77:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/into_url.rs:10:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/into_url_with_base.rs:9:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/job.rs:20:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/lev_distance.rs:3:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/lockserver.rs:111:32 clippy::redundant_else "redundant else block"
+cargo-0.49.0/src/cargo/util/lockserver.rs:158:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/lockserver.rs:46:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/lockserver.rs:58:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/lockserver.rs:62:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/mod.rs:68:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/mod.rs:79:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/network.rs:12:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/network.rs:19:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/network.rs:84:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/paths.rs:109:12 clippy::redundant_else "redundant else block"
+cargo-0.49.0/src/cargo/util/paths.rs:114:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/paths.rs:121:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/paths.rs:125:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/paths.rs:130:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/paths.rs:14:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/paths.rs:14:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+cargo-0.49.0/src/cargo/util/paths.rs:151:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/paths.rs:167:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/paths.rs:173:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/paths.rs:178:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/paths.rs:185:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/paths.rs:199:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/paths.rs:215:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/paths.rs:228:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/paths.rs:251:9 clippy::option_if_let_else "use Option::map_or instead of an if let/else"
+cargo-0.49.0/src/cargo/util/paths.rs:267:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/paths.rs:276:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/paths.rs:29:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/paths.rs:303:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/paths.rs:312:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/paths.rs:346:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/paths.rs:415:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/paths.rs:445:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/paths.rs:459:45 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/util/paths.rs:469:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/paths.rs:54:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/paths.rs:61:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/paths.rs:63:19 clippy::option_if_let_else "use Option::map_or_else instead of an if let/else"
+cargo-0.49.0/src/cargo/util/paths.rs:88:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/paths.rs:93:31 clippy::comparison_to_empty "comparison to empty slice"
+cargo-0.49.0/src/cargo/util/process_builder.rs:106:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/process_builder.rs:111:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/process_builder.rs:122:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/process_builder.rs:132:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/process_builder.rs:152:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/process_builder.rs:185:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/process_builder.rs:190:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/process_builder.rs:218:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/process_builder.rs:307:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/process_builder.rs:343:39 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+cargo-0.49.0/src/cargo/util/progress.rs:122:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/progress.rs:136:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/progress.rs:15:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/util/progress.rs:249:19 clippy::cast_precision_loss "casting `usize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`usize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+cargo-0.49.0/src/cargo/util/progress.rs:249:34 clippy::cast_precision_loss "casting `usize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`usize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+cargo-0.49.0/src/cargo/util/progress.rs:250:19 clippy::if_not_else "unnecessary boolean `not` operation"
+cargo-0.49.0/src/cargo/util/progress.rs:263:22 clippy::cast_precision_loss "casting `usize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`usize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+cargo-0.49.0/src/cargo/util/progress.rs:264:22 clippy::cast_possible_truncation "casting `f64` to `usize` may truncate the value"
+cargo-0.49.0/src/cargo/util/progress.rs:264:22 clippy::cast_sign_loss "casting `f64` to `usize` may lose the sign of the value"
+cargo-0.49.0/src/cargo/util/progress.rs:269:17 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
+cargo-0.49.0/src/cargo/util/progress.rs:272:17 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
+cargo-0.49.0/src/cargo/util/progress.rs:274:17 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
+cargo-0.49.0/src/cargo/util/progress.rs:280:13 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
+cargo-0.49.0/src/cargo/util/progress.rs:282:9 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
+cargo-0.49.0/src/cargo/util/progress.rs:89:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/progress.rs:97:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/queue.rs:25:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/read2.rs:11:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/read2.rs:31:17 clippy::similar_names "binding's name is too similar to existing binding"
+cargo-0.49.0/src/cargo/util/restricted_names.rs:13:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/restricted_names.rs:26:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/restricted_names.rs:35:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/restricted_names.rs:45:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/restricted_names.rs:87:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/restricted_names.rs:89:21 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/util/restricted_names.rs:8:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/rustc.rs:103:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/rustc.rs:114:5 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
+cargo-0.49.0/src/cargo/util/rustc.rs:115:5 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
+cargo-0.49.0/src/cargo/util/rustc.rs:162:17 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/util/rustc.rs:39:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/sha256.rs:10:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/sha256.rs:20:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/sha256.rs:31:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/sha256.rs:40:24 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+cargo-0.49.0/src/cargo/util/to_semver.rs:5:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:1005:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:1005:5 clippy::too_many_lines "this function has too many lines (282/100)"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:1094:36 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:1121:13 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:1197:32 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:124:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:1504:9 clippy::unused_self "unused `self` argument"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:1526:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:1582:19 clippy::default_trait_access "calling `util::toml::DetailedTomlDependency::default()` is more clear than this expression"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:1598:5 clippy::too_many_lines "this function has too many lines (153/100)"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:1687:33 clippy::unnecessary_lazy_evaluations "unnecessary closure used to substitute value for `Option::None`"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:178:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:248:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:274:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:277:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:281:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:285:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:294:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:31:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:381:35 clippy::cast_possible_truncation "casting `i64` to `u32` may truncate the value"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:381:35 clippy::cast_sign_loss "casting `i64` to `u32` may lose the sign of the value"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:388:35 clippy::cast_possible_truncation "casting `u64` to `u32` may truncate the value"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:398:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:450:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:536:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:783:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:824:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:834:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:83:42 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:852:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:852:5 clippy::too_many_lines "this function has too many lines (138/100)"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:962:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:979:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:98:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/util/toml/mod.rs:999:23 clippy::default_trait_access "calling `util::toml::DetailedTomlDependency::default()` is more clear than this expression"
+cargo-0.49.0/src/cargo/util/toml/targets.rs:112:27 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/util/toml/targets.rs:325:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+cargo-0.49.0/src/cargo/util/toml/targets.rs:586:21 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/util/toml/targets.rs:593:42 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/util/toml/targets.rs:605:19 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/util/toml/targets.rs:612:42 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/util/toml/targets.rs:756:36 clippy::redundant_closure_for_method_calls "redundant closure found"
+cargo-0.49.0/src/cargo/util/vcs.rs:10:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+cargo-0.49.0/src/cargo/util/vcs.rs:33:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/vcs.rs:37:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/vcs.rs:43:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/vcs.rs:47:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/vcs.rs:59:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/vcs.rs:66:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/workspace.rs:52:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/workspace.rs:56:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/workspace.rs:60:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+cargo-0.49.0/src/cargo/util/workspace.rs:64:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+iron-0.6.1/src/error.rs:24:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+iron-0.6.1/src/iron.rs:105:13 clippy::redundant_field_names "redundant field names in struct initialization"
+iron-0.6.1/src/iron.rs:119:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+iron-0.6.1/src/iron.rs:133:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+iron-0.6.1/src/iron.rs:143:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+iron-0.6.1/src/iron.rs:149:13 clippy::redundant_field_names "redundant field names in struct initialization"
+iron-0.6.1/src/iron.rs:167:49 clippy::similar_names "binding's name is too similar to existing binding"
+iron-0.6.1/src/iron.rs:80:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+iron-0.6.1/src/iron.rs:85:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+iron-0.6.1/src/iron.rs:90:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+iron-0.6.1/src/lib.rs:1:null clippy::cargo_common_metadata "package `iron` is missing `package.categories` metadata"
+iron-0.6.1/src/lib.rs:1:null clippy::cargo_common_metadata "package `iron` is missing `package.keywords` metadata"
+iron-0.6.1/src/lib.rs:1:null clippy::multiple_crate_versions "multiple versions for dependency `log`: 0.3.9, 0.4.8"
+iron-0.6.1/src/middleware/mod.rs:137:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+iron-0.6.1/src/middleware/mod.rs:150:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+iron-0.6.1/src/middleware/mod.rs:152:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+iron-0.6.1/src/middleware/mod.rs:159:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+iron-0.6.1/src/middleware/mod.rs:171:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+iron-0.6.1/src/middleware/mod.rs:173:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+iron-0.6.1/src/middleware/mod.rs:182:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+iron-0.6.1/src/middleware/mod.rs:192:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+iron-0.6.1/src/middleware/mod.rs:217:25 clippy::doc_markdown "you should put `ChainBuilder` between ticks in the documentation"
+iron-0.6.1/src/middleware/mod.rs:328:20 clippy::similar_names "binding's name is too similar to existing binding"
+iron-0.6.1/src/middleware/mod.rs:360:16 clippy::similar_names "binding's name is too similar to existing binding"
+iron-0.6.1/src/middleware/mod.rs:368:33 clippy::similar_names "binding's name is too similar to existing binding"
+iron-0.6.1/src/middleware/mod.rs:428:40 clippy::similar_names "binding's name is too similar to existing binding"
+iron-0.6.1/src/middleware/mod.rs:434:40 clippy::similar_names "binding's name is too similar to existing binding"
+iron-0.6.1/src/middleware/mod.rs:444:40 clippy::similar_names "binding's name is too similar to existing binding"
+iron-0.6.1/src/modifiers.rs:132:14 clippy::expect_fun_call "use of `expect` followed by a function call"
+iron-0.6.1/src/request/mod.rs:113:24 clippy::similar_names "binding's name is too similar to existing binding"
+iron-0.6.1/src/request/mod.rs:121:13 clippy::redundant_field_names "redundant field names in struct initialization"
+iron-0.6.1/src/request/mod.rs:123:13 clippy::redundant_field_names "redundant field names in struct initialization"
+iron-0.6.1/src/request/mod.rs:124:13 clippy::redundant_field_names "redundant field names in struct initialization"
+iron-0.6.1/src/request/mod.rs:126:13 clippy::redundant_field_names "redundant field names in struct initialization"
+iron-0.6.1/src/request/mod.rs:128:13 clippy::redundant_field_names "redundant field names in struct initialization"
+iron-0.6.1/src/request/mod.rs:153:69 clippy::doc_markdown "you should put `HttpReader` between ticks in the documentation"
+iron-0.6.1/src/request/mod.rs:154:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+iron-0.6.1/src/request/mod.rs:32:1 clippy::manual_non_exhaustive "this seems like a manual implementation of the non-exhaustive pattern"
+iron-0.6.1/src/request/mod.rs:75:34 clippy::doc_markdown "you should put `HttpRequest` between ticks in the documentation"
+iron-0.6.1/src/request/mod.rs:77:39 clippy::doc_markdown "you should put `HttpRequest` between ticks in the documentation"
+iron-0.6.1/src/request/mod.rs:78:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+iron-0.6.1/src/request/mod.rs:82:13 clippy::similar_names "binding's name is too similar to existing binding"
+iron-0.6.1/src/request/mod.rs:83:29 clippy::similar_names "binding's name is too similar to existing binding"
+iron-0.6.1/src/request/mod.rs:85:24 clippy::similar_names "binding's name is too similar to existing binding"
+iron-0.6.1/src/request/url.rs:109:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+iron-0.6.1/src/request/url.rs:117:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+iron-0.6.1/src/request/url.rs:129:1 clippy::from_over_into "an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true"
+iron-0.6.1/src/request/url.rs:21:14 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
+iron-0.6.1/src/request/url.rs:22:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+iron-0.6.1/src/request/url.rs:31:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+iron-0.6.1/src/request/url.rs:47:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+iron-0.6.1/src/request/url.rs:52:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+iron-0.6.1/src/request/url.rs:57:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+iron-0.6.1/src/request/url.rs:63:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+iron-0.6.1/src/request/url.rs:73:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+iron-0.6.1/src/request/url.rs:83:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+iron-0.6.1/src/request/url.rs:96:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+iron-0.6.1/src/response.rs:121:19 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+iron-0.6.1/src/response.rs:125:43 clippy::redundant_closure_for_method_calls "redundant closure found"
+iron-0.6.1/src/response.rs:139:41 clippy::redundant_closure_for_method_calls "redundant closure found"
+iron-0.6.1/src/response.rs:24:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+iron-0.6.1/src/response.rs:95:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+iron-0.6.1/src/response.rs:95:5 clippy::new_without_default "you should consider adding a `Default` implementation for `response::Response`"
+libc-0.2.81/build.rs:114:19 clippy::map_unwrap_or "called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead"
+libc-0.2.81/build.rs:124:5 clippy::question_mark "this block may be rewritten with the `?` operator"
+libc-0.2.81/build.rs:133:5 clippy::question_mark "this block may be rewritten with the `?` operator"
+libc-0.2.81/src/macros.rs:243:17 clippy::missing_safety_doc "unsafe function's docs miss `# Safety` section"
+libc-0.2.81/src/macros.rs:243:17 clippy::missing_safety_doc "unsafe function's docs miss `# Safety` section"
+libc-0.2.81/src/macros.rs:243:17 clippy::missing_safety_doc "unsafe function's docs miss `# Safety` section"
+libc-0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/macros.rs:243:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/macros.rs:259:null clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:428:29 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:429:30 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:431:30 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:432:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:433:29 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:434:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:595:33 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:596:33 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:597:35 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:622:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:673:34 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:696:33 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:697:35 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:698:33 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:699:35 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:712:34 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:721:35 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:722:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:723:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:751:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:752:30 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:753:30 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:754:30 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:755:29 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:756:29 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:757:29 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:758:29 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:759:29 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:760:29 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:768:30 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:769:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:771:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:772:29 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:773:29 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:774:29 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:775:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:776:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:777:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:778:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:779:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:780:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:781:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:782:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:783:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:784:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:785:33 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:786:33 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:787:30 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:788:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:789:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:790:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:791:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:792:33 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:794:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:795:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:796:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:797:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:798:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:799:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:800:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:801:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:803:27 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:804:28 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:805:28 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:806:29 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:807:29 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:808:29 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:809:29 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:810:29 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:811:29 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:812:30 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:813:30 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:814:30 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:815:30 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:816:30 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:817:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:818:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:821:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:822:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:823:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:824:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:825:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:826:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:827:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:828:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:829:33 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:830:33 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:831:33 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:832:33 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:833:33 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:834:33 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:835:33 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:836:33 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:841:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:842:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:843:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs:844:33 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:1120:38 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:178:34 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:291:5 clippy::missing_safety_doc "unsafe function's docs miss `# Safety` section"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:291:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:299:11 clippy::ptr_as_ptr "`as` casting between raw pointers without changing its mutability"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:302:5 clippy::missing_safety_doc "unsafe function's docs miss `# Safety` section"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:302:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:312:11 clippy::ptr_as_ptr "`as` casting between raw pointers without changing its mutability"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:352:20 clippy::ptr_as_ptr "`as` casting between raw pointers without changing its mutability"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:355:13 clippy::missing_safety_doc "unsafe function's docs miss `# Safety` section"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:355:13 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:359:13 clippy::missing_safety_doc "unsafe function's docs miss `# Safety` section"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:359:13 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:363:13 clippy::missing_safety_doc "unsafe function's docs miss `# Safety` section"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:363:13 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:367:13 clippy::missing_safety_doc "unsafe function's docs miss `# Safety` section"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:367:13 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:371:13 clippy::missing_safety_doc "unsafe function's docs miss `# Safety` section"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:371:13 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:534:36 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:645:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:727:40 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:728:40 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:729:39 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:731:44 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:732:36 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:733:41 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:734:43 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:735:42 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:736:40 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:737:36 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:738:37 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:741:39 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:742:40 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:743:40 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:744:40 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:745:40 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:746:43 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:747:42 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:748:40 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:749:39 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:750:41 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:751:41 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:752:43 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:753:42 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:755:42 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:756:41 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:757:41 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:758:39 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:759:39 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:761:41 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:762:44 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:763:45 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:764:40 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:765:40 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:766:40 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:767:44 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:768:44 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:769:39 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:770:35 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:771:35 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:772:37 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:773:39 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:774:45 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:775:41 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:776:39 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:803:34 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:841:30 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:842:37 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:982:40 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/gnu/mod.rs:984:46 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1209:36 clippy::cast_possible_truncation "casting `i32` to `i16` may truncate the value"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1210:36 clippy::cast_possible_truncation "casting `i32` to `i16` may truncate the value"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1235:39 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1236:41 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1274:42 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1324:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1333:37 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1334:35 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1346:34 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1346:34 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1346:34 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1347:37 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1347:37 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1347:37 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1348:36 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1348:36 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1348:36 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1349:37 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1349:37 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1349:37 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1350:35 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1350:35 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1350:35 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1351:36 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1351:36 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1351:36 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1352:31 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1352:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1352:31 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1419:36 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1420:36 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1421:36 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1422:36 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1423:36 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1490:37 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1561:46 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1562:45 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1567:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1568:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1586:26 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1587:34 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1588:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1589:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1897:38 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1898:51 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1900:39 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1969:34 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1970:34 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1971:36 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1972:36 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1973:36 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1974:37 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1975:37 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1976:36 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1977:36 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1978:39 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1979:39 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1980:39 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1981:39 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1982:39 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1983:39 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1984:38 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1985:38 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1986:35 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1987:35 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1988:35 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1989:35 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1990:38 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1991:37 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1992:37 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1993:38 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1994:37 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1995:37 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1996:37 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1997:37 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1998:33 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:1999:33 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2000:33 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2001:34 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2002:34 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2003:34 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2004:35 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2005:35 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2032:30 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2033:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2034:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2035:29 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2036:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2037:28 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2038:27 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2039:29 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2041:29 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2042:28 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2043:27 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2044:34 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2045:27 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2046:33 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2048:28 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2049:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2050:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2051:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2052:26 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2053:36 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2318:42 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2321:38 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2331:39 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2487:42 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2488:42 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2489:43 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2490:43 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2491:43 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2493:47 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2494:44 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2495:46 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2496:47 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2497:49 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2498:48 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2499:50 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2500:45 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2572:9 clippy::needless_return "unneeded `return` statement"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2578:20 clippy::zero_ptr "`0 as *mut _` detected"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2588:13 clippy::zero_ptr "`0 as *mut _` detected"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2590:13 clippy::ptr_as_ptr "`as` casting between raw pointers without changing its mutability"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2596:52 clippy::used_underscore_binding "used binding `_dummy` which is prefixed with an underscore. A leading underscore signals that a binding will not be used."
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2597:11 clippy::cast_sign_loss "casting `i32` to `usize` may lose the sign of the value"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2601:21 clippy::explicit_iter_loop "it is more concise to loop over references to containers instead of using explicit iteration methods"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2611:9 clippy::unused_unit "unneeded unit expression"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2619:9 clippy::unused_unit "unneeded unit expression"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2634:9 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2647:25 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2648:25 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2649:9 clippy::cast_possible_truncation "casting `u64` to `u32` may truncate the value"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2654:18 clippy::identity_op "the operation is ineffective. Consider reducing it to `(dev & 0x00000000000000ff)`"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2654:25 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2655:25 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2656:9 clippy::cast_possible_truncation "casting `u64` to `u32` may truncate the value"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2660:21 clippy::cast_lossless "casting `u32` to `u64` may become silently lossy if you later change the type"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2661:21 clippy::cast_lossless "casting `u32` to `u64` may become silently lossy if you later change the type"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2663:25 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2664:25 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2665:16 clippy::identity_op "the operation is ineffective. Consider reducing it to `(minor & 0x000000ff)`"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2665:25 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:2666:25 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/linux/mod.rs:954:34 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1000:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1001:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1002:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1016:29 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1017:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1018:33 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1019:33 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1020:33 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1029:29 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1030:29 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1031:30 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1032:29 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1033:29 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1034:29 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1035:29 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1041:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1042:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1043:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1044:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1045:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1046:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1047:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1048:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1049:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1050:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1051:33 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1053:29 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1054:33 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1055:30 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1056:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1057:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1058:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1059:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1060:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1073:42 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1074:43 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1075:37 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1076:37 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1077:41 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1078:35 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1079:35 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1080:36 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1081:35 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1082:35 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1083:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1084:38 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1086:30 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1087:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1089:30 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1090:33 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1091:30 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1094:40 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1095:37 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1096:41 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1097:40 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1098:39 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1099:34 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1100:36 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1101:38 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1102:37 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1105:44 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1106:41 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1107:42 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1108:42 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1109:41 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1110:46 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1111:41 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1112:44 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1113:40 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1114:47 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1115:36 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1126:34 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1127:29 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1128:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1179:32 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1180:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:1218:27 clippy::identity_op "the operation is ineffective. Consider reducing it to `IPOPT_CONTROL`"
+libc-0.2.81/src/unix/linux_like/mod.rs:1314:9 clippy::precedence "operator precedence can trip the unwary"
+libc-0.2.81/src/unix/linux_like/mod.rs:1321:13 clippy::ptr_as_ptr "`as` casting between raw pointers without changing its mutability"
+libc-0.2.81/src/unix/linux_like/mod.rs:1323:13 clippy::zero_ptr "`0 as *mut _` detected"
+libc-0.2.81/src/unix/linux_like/mod.rs:1332:9 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+libc-0.2.81/src/unix/linux_like/mod.rs:1337:9 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+libc-0.2.81/src/unix/linux_like/mod.rs:1341:18 clippy::cast_sign_loss "casting `i32` to `usize` may lose the sign of the value"
+libc-0.2.81/src/unix/linux_like/mod.rs:1344:9 clippy::needless_return "unneeded `return` statement"
+libc-0.2.81/src/unix/linux_like/mod.rs:1348:18 clippy::cast_sign_loss "casting `i32` to `usize` may lose the sign of the value"
+libc-0.2.81/src/unix/linux_like/mod.rs:1350:9 clippy::needless_return "unneeded `return` statement"
+libc-0.2.81/src/unix/linux_like/mod.rs:1354:18 clippy::cast_sign_loss "casting `i32` to `usize` may lose the sign of the value"
+libc-0.2.81/src/unix/linux_like/mod.rs:1357:9 clippy::needless_return "unneeded `return` statement"
+libc-0.2.81/src/unix/linux_like/mod.rs:1361:21 clippy::explicit_iter_loop "it is more concise to loop over references to containers instead of using explicit iteration methods"
+libc-0.2.81/src/unix/linux_like/mod.rs:1381:9 clippy::cast_possible_truncation "casting `i32` to `i8` may truncate the value"
+libc-0.2.81/src/unix/linux_like/mod.rs:1389:9 clippy::verbose_bit_mask "bit mask could be simplified with a call to `trailing_zeros`"
+libc-0.2.81/src/unix/linux_like/mod.rs:446:31 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:591:36 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:592:38 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:593:35 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:594:33 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:595:34 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:596:36 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:597:37 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:598:37 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:599:39 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:600:34 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:601:35 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:602:35 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:607:37 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:608:35 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:764:35 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:765:39 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/linux_like/mod.rs:991:30 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/mod.rs:198:29 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/mod.rs:199:28 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/mod.rs:201:35 clippy::unnecessary_cast "casting integer literal to `usize` is unnecessary"
+libc-0.2.81/src/unix/mod.rs:202:35 clippy::unnecessary_cast "casting integer literal to `usize` is unnecessary"
+libc-0.2.81/src/unix/mod.rs:282:40 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/mod.rs:284:41 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/mod.rs:285:36 clippy::unreadable_literal "long literal lacking separators"
+libc-0.2.81/src/unix/mod.rs:34:10 clippy::upper_case_acronyms "name `DIR` contains a capitalized acronym"
+libc-0.2.81/src/unix/mod.rs:386:10 clippy::upper_case_acronyms "name `FILE` contains a capitalized acronym"
+log-0.4.11/src/lib.rs:1047:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log-0.4.11/src/lib.rs:1053:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log-0.4.11/src/lib.rs:1059:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log-0.4.11/src/lib.rs:1093:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log-0.4.11/src/lib.rs:1093:5 clippy::new_without_default "you should consider adding a `Default` implementation for `MetadataBuilder<'a>`"
+log-0.4.11/src/lib.rs:1118:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log-0.4.11/src/lib.rs:1177:1 clippy::inline_always "you have declared `#[inline(always)]` on `max_level`. This is usually a bad idea"
+log-0.4.11/src/lib.rs:1178:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+log-0.4.11/src/lib.rs:1306:1 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+log-0.4.11/src/lib.rs:1358:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+log-0.4.11/src/lib.rs:1359:5 clippy::if_not_else "unnecessary `!=` operation"
+log-0.4.11/src/lib.rs:1407:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+log-0.4.11/src/lib.rs:329:27 clippy::derive_hash_xor_eq "you are deriving `Hash` but have implemented `PartialEq` explicitly"
+log-0.4.11/src/lib.rs:356:1 clippy::expl_impl_clone_on_copy "you are implementing `Clone` explicitly on a `Copy` type"
+log-0.4.11/src/lib.rs:448:12 clippy::manual_range_contains "manual `RangeInclusive::contains` implementation"
+log-0.4.11/src/lib.rs:500:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log-0.4.11/src/lib.rs:506:28 clippy::trivially_copy_pass_by_ref "this argument (8 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+log-0.4.11/src/lib.rs:506:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log-0.4.11/src/lib.rs:520:27 clippy::derive_hash_xor_eq "you are deriving `Hash` but have implemented `PartialEq` explicitly"
+log-0.4.11/src/lib.rs:538:1 clippy::expl_impl_clone_on_copy "you are implementing `Clone` explicitly on a `Copy` type"
+log-0.4.11/src/lib.rs:653:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log-0.4.11/src/lib.rs:661:21 clippy::trivially_copy_pass_by_ref "this argument (8 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+log-0.4.11/src/lib.rs:661:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log-0.4.11/src/lib.rs:677:44 clippy::match_same_arms "this `match` has identical arm bodies"
+log-0.4.11/src/lib.rs:758:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log-0.4.11/src/lib.rs:764:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log-0.4.11/src/lib.rs:770:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log-0.4.11/src/lib.rs:776:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log-0.4.11/src/lib.rs:782:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log-0.4.11/src/lib.rs:788:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log-0.4.11/src/lib.rs:794:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log-0.4.11/src/lib.rs:803:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log-0.4.11/src/lib.rs:809:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log-0.4.11/src/lib.rs:818:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log-0.4.11/src/lib.rs:908:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+log-0.4.11/src/lib.rs:908:5 clippy::new_without_default "you should consider adding a `Default` implementation for `RecordBuilder<'a>`"
+log-0.4.11/src/lib.rs:995:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2-1.0.24/src/detection.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+proc-macro2-1.0.24/src/fallback.rs:108:17 clippy::match_wildcard_for_single_variants "wildcard match will miss any future added variants"
+proc-macro2-1.0.24/src/fallback.rs:269:20 clippy::unused_self "unused `self` argument"
+proc-macro2-1.0.24/src/fallback.rs:430:24 clippy::trivially_copy_pass_by_ref "this argument (0 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+proc-macro2-1.0.24/src/fallback.rs:437:23 clippy::trivially_copy_pass_by_ref "this argument (0 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+proc-macro2-1.0.24/src/fallback.rs:437:23 clippy::unused_self "unused `self` argument"
+proc-macro2-1.0.24/src/fallback.rs:471:17 clippy::trivially_copy_pass_by_ref "this argument (0 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+proc-macro2-1.0.24/src/fallback.rs:471:17 clippy::unused_self "unused `self` argument"
+proc-macro2-1.0.24/src/fallback.rs:654:5 clippy::manual_range_contains "manual `RangeInclusive::contains` implementation"
+proc-macro2-1.0.24/src/fallback.rs:655:12 clippy::manual_range_contains "manual `RangeInclusive::contains` implementation"
+proc-macro2-1.0.24/src/fallback.rs:661:5 clippy::manual_range_contains "manual `RangeInclusive::contains` implementation"
+proc-macro2-1.0.24/src/fallback.rs:662:12 clippy::manual_range_contains "manual `RangeInclusive::contains` implementation"
+proc-macro2-1.0.24/src/fallback.rs:664:12 clippy::manual_range_contains "manual `RangeInclusive::contains` implementation"
+proc-macro2-1.0.24/src/fallback.rs:674:37 clippy::manual_range_contains "manual `RangeInclusive::contains` implementation"
+proc-macro2-1.0.24/src/fallback.rs:678:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+proc-macro2-1.0.24/src/fallback.rs:85:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+proc-macro2-1.0.24/src/fallback.rs:882:43 clippy::unused_self "unused `self` argument"
+proc-macro2-1.0.24/src/lib.rs:1017:9 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2-1.0.24/src/lib.rs:1081:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2-1.0.24/src/lib.rs:1099:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2-1.0.24/src/lib.rs:1117:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2-1.0.24/src/lib.rs:1135:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2-1.0.24/src/lib.rs:1141:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2-1.0.24/src/lib.rs:1146:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2-1.0.24/src/lib.rs:1151:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2-1.0.24/src/lib.rs:1156:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2-1.0.24/src/lib.rs:152:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2-1.0.24/src/lib.rs:157:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2-1.0.24/src/lib.rs:373:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2-1.0.24/src/lib.rs:383:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2-1.0.24/src/lib.rs:397:24 clippy::trivially_copy_pass_by_ref "this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+proc-macro2-1.0.24/src/lib.rs:397:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2-1.0.24/src/lib.rs:403:23 clippy::trivially_copy_pass_by_ref "this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+proc-macro2-1.0.24/src/lib.rs:403:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2-1.0.24/src/lib.rs:418:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2-1.0.24/src/lib.rs:425:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2-1.0.24/src/lib.rs:464:17 clippy::trivially_copy_pass_by_ref "this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+proc-macro2-1.0.24/src/lib.rs:500:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2-1.0.24/src/lib.rs:626:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2-1.0.24/src/lib.rs:633:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2-1.0.24/src/lib.rs:641:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2-1.0.24/src/lib.rs:652:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2-1.0.24/src/lib.rs:662:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2-1.0.24/src/lib.rs:672:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2-1.0.24/src/lib.rs:734:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2-1.0.24/src/lib.rs:743:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2-1.0.24/src/lib.rs:752:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2-1.0.24/src/lib.rs:757:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2-1.0.24/src/lib.rs:788:19 clippy::doc_markdown "you should put `XID_Start` between ticks in the documentation"
+proc-macro2-1.0.24/src/lib.rs:788:69 clippy::doc_markdown "you should put `XID_Continue` between ticks in the documentation"
+proc-macro2-1.0.24/src/lib.rs:891:36 clippy::doc_markdown "you should put `syn::parse_str` between ticks in the documentation"
+proc-macro2-1.0.24/src/lib.rs:894:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2-1.0.24/src/lib.rs:911:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2-1.0.24/src/lib.rs:996:9 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+proc-macro2-1.0.24/src/parse.rs:552:5 clippy::while_let_on_iterator "this loop could be written as a `for` loop"
+proc-macro2-1.0.24/src/parse.rs:584:21 clippy::manual_range_contains "manual `RangeInclusive::contains` implementation"
+proc-macro2-1.0.24/src/parse.rs:602:20 clippy::map_unwrap_or "called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead"
+proc-macro2-1.0.24/src/parse.rs:696:29 clippy::cast_lossless "casting `u8` to `u64` may become silently lossy if you later change the type"
+proc-macro2-1.0.24/src/parse.rs:702:34 clippy::cast_lossless "casting `u8` to `u64` may become silently lossy if you later change the type"
+proc-macro2-1.0.24/src/parse.rs:708:34 clippy::cast_lossless "casting `u8` to `u64` may become silently lossy if you later change the type"
+proc-macro2-1.0.24/src/parse.rs:793:5 clippy::vec_init_then_push "calls to `push` immediately after creation"
+proc-macro2-1.0.24/src/parse.rs:803:15 clippy::explicit_iter_loop "it is more concise to loop over references to containers instead of using explicit iteration methods"
+proc-macro2-1.0.24/src/parse.rs:808:15 clippy::explicit_iter_loop "it is more concise to loop over references to containers instead of using explicit iteration methods"
+proc-macro2-1.0.24/src/wrapper.rs:415:24 clippy::trivially_copy_pass_by_ref "this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+proc-macro2-1.0.24/src/wrapper.rs:429:23 clippy::trivially_copy_pass_by_ref "this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+proc-macro2-1.0.24/src/wrapper.rs:492:17 clippy::trivially_copy_pass_by_ref "this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+quote-1.0.7/src/ext.rs:10:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+quote-1.0.7/src/ext.rs:7:5 clippy::doc_markdown "you should put `TokenStream` between ticks in the documentation"
+quote-1.0.7/src/ident_fragment.rs:13:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+quote-1.0.7/src/ident_fragment.rs:51:31 clippy::manual_strip "stripping a prefix manually"
+quote-1.0.7/src/runtime.rs:52:5 clippy::module_name_repetitions "item name ends with its containing module's name"
+quote-1.0.7/src/runtime.rs:63:5 clippy::module_name_repetitions "item name ends with its containing module's name"
+quote-1.0.7/src/runtime.rs:66:33 clippy::doc_markdown "you should put `DoesNotHaveIter` between ticks in the documentation"
+quote-1.0.7/src/runtime.rs:80:5 clippy::module_name_repetitions "item name ends with its containing module's name"
+rand-0.7.3/src/distributions/bernoulli.rs:103:20 clippy::cast_possible_truncation "casting `f64` to `u64` may truncate the value"
+rand-0.7.3/src/distributions/bernoulli.rs:103:20 clippy::cast_sign_loss "casting `f64` to `u64` may lose the sign of the value"
+rand-0.7.3/src/distributions/bernoulli.rs:116:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+rand-0.7.3/src/distributions/bernoulli.rs:123:21 clippy::cast_possible_truncation "casting `f64` to `u64` may truncate the value"
+rand-0.7.3/src/distributions/bernoulli.rs:123:21 clippy::cast_sign_loss "casting `f64` to `u64` may lose the sign of the value"
+rand-0.7.3/src/distributions/bernoulli.rs:63:26 clippy::cast_precision_loss "casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand-0.7.3/src/distributions/bernoulli.rs:63:27 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+rand-0.7.3/src/distributions/bernoulli.rs:67:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand-0.7.3/src/distributions/bernoulli.rs:95:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+rand-0.7.3/src/distributions/bernoulli.rs:96:13 clippy::manual_range_contains "manual `Range::contains` implementation"
+rand-0.7.3/src/distributions/binomial.rs:107:23 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand-0.7.3/src/distributions/binomial.rs:112:44 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand-0.7.3/src/distributions/binomial.rs:116:13 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rand-0.7.3/src/distributions/binomial.rs:150:28 clippy::redundant_else "redundant else block"
+rand-0.7.3/src/distributions/binomial.rs:153:24 clippy::if_not_else "unnecessary boolean `not` operation"
+rand-0.7.3/src/distributions/binomial.rs:158:28 clippy::redundant_else "redundant else block"
+rand-0.7.3/src/distributions/binomial.rs:164:33 clippy::cast_sign_loss "casting `i64` to `u64` may lose the sign of the value"
+rand-0.7.3/src/distributions/binomial.rs:166:28 clippy::redundant_else "redundant else block"
+rand-0.7.3/src/distributions/binomial.rs:175:47 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand-0.7.3/src/distributions/binomial.rs:185:38 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand-0.7.3/src/distributions/binomial.rs:194:38 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand-0.7.3/src/distributions/binomial.rs:202:28 clippy::redundant_else "redundant else block"
+rand-0.7.3/src/distributions/binomial.rs:209:25 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand-0.7.3/src/distributions/binomial.rs:221:26 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand-0.7.3/src/distributions/binomial.rs:222:26 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand-0.7.3/src/distributions/binomial.rs:223:25 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand-0.7.3/src/distributions/binomial.rs:224:25 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand-0.7.3/src/distributions/binomial.rs:226:17 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rand-0.7.3/src/distributions/binomial.rs:233:32 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand-0.7.3/src/distributions/binomial.rs:234:27 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand-0.7.3/src/distributions/binomial.rs:251:22 clippy::cast_sign_loss "casting `i64` to `u64` may lose the sign of the value"
+rand-0.7.3/src/distributions/binomial.rs:255:9 clippy::if_not_else "unnecessary `!=` operation"
+rand-0.7.3/src/distributions/binomial.rs:35:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand-0.7.3/src/distributions/binomial.rs:45:17 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand-0.7.3/src/distributions/binomial.rs:46:5 clippy::cast_possible_truncation "casting `f64` to `i64` may truncate the value"
+rand-0.7.3/src/distributions/binomial.rs:50:5 clippy::too_many_lines "this function has too many lines (143/100)"
+rand-0.7.3/src/distributions/binomial.rs:76:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rand-0.7.3/src/distributions/binomial.rs:78:12 clippy::cast_precision_loss "casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand-0.7.3/src/distributions/binomial.rs:81:21 clippy::cast_precision_loss "casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand-0.7.3/src/distributions/binomial.rs:82:32 clippy::cast_possible_truncation "casting `u64` to `i32` may truncate the value"
+rand-0.7.3/src/distributions/binomial.rs:88:26 clippy::cast_precision_loss "casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand-0.7.3/src/distributions/binomial.rs:99:21 clippy::cast_precision_loss "casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand-0.7.3/src/distributions/cauchy.rs:33:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand-0.7.3/src/distributions/dirichlet.rs:52:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand-0.7.3/src/distributions/dirichlet.rs:64:32 clippy::unseparated_literal_suffix "float type suffix should be separated by an underscore"
+rand-0.7.3/src/distributions/dirichlet.rs:65:23 clippy::unseparated_literal_suffix "float type suffix should be separated by an underscore"
+rand-0.7.3/src/distributions/exponential.rs:76:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand-0.7.3/src/distributions/float.rs:73:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+rand-0.7.3/src/distributions/gamma.rs:13:5 clippy::enum_glob_use "usage of wildcard import for enum variants"
+rand-0.7.3/src/distributions/gamma.rs:14:5 clippy::enum_glob_use "usage of wildcard import for enum variants"
+rand-0.7.3/src/distributions/gamma.rs:189:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand-0.7.3/src/distributions/gamma.rs:230:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand-0.7.3/src/distributions/gamma.rs:259:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand-0.7.3/src/distributions/gamma.rs:287:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand-0.7.3/src/distributions/gamma.rs:90:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand-0.7.3/src/distributions/integer.rs:23:9 clippy::cast_possible_truncation "casting `u32` to `u8` may truncate the value"
+rand-0.7.3/src/distributions/integer.rs:30:9 clippy::cast_possible_truncation "casting `u32` to `u16` may truncate the value"
+rand-0.7.3/src/distributions/integer.rs:69:9 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
+rand-0.7.3/src/distributions/mod.rs:263:5 clippy::inline_always "you have declared `#[inline(always)]` on `next`. This is usually a bad idea"
+rand-0.7.3/src/distributions/normal.rs:100:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand-0.7.3/src/distributions/normal.rs:119:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+rand-0.7.3/src/distributions/normal.rs:131:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand-0.7.3/src/distributions/normal.rs:31:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+rand-0.7.3/src/distributions/normal.rs:47:25 clippy::unseparated_literal_suffix "float type suffix should be separated by an underscore"
+rand-0.7.3/src/distributions/normal.rs:48:25 clippy::unseparated_literal_suffix "float type suffix should be separated by an underscore"
+rand-0.7.3/src/distributions/other.rs:89:9 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
+rand-0.7.3/src/distributions/pareto.rs:32:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand-0.7.3/src/distributions/poisson.rs:35:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand-0.7.3/src/distributions/poisson.rs:87:30 clippy::cast_possible_truncation "casting `f64` to `u64` may truncate the value"
+rand-0.7.3/src/distributions/poisson.rs:87:30 clippy::cast_sign_loss "casting `f64` to `u64` may lose the sign of the value"
+rand-0.7.3/src/distributions/triangular.rs:32:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand-0.7.3/src/distributions/uniform.rs:146:4 clippy::needless_doctest_main "needless `fn main` in doctest"
+rand-0.7.3/src/distributions/uniform.rs:199:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+rand-0.7.3/src/distributions/uniform.rs:214:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand-0.7.3/src/distributions/uniform.rs:283:14 clippy::doc_markdown "you should put `SampleUniform` between ticks in the documentation"
+rand-0.7.3/src/distributions/uniform.rs:283:46 clippy::doc_markdown "you should put `SampleUniform` between ticks in the documentation"
+rand-0.7.3/src/distributions/uniform.rs:296:5 clippy::inline_always "you have declared `#[inline(always)]` on `borrow`. This is usually a bad idea"
+rand-0.7.3/src/distributions/uniform.rs:304:5 clippy::inline_always "you have declared `#[inline(always)]` on `borrow`. This is usually a bad idea"
+rand-0.7.3/src/distributions/uniform.rs:350:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand-0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
+rand-0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
+rand-0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
+rand-0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
+rand-0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
+rand-0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
+rand-0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
+rand-0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
+rand-0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
+rand-0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
+rand-0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
+rand-0.7.3/src/distributions/uniform.rs:407:21 clippy::redundant_field_names "redundant field names in struct initialization"
+rand-0.7.3/src/distributions/uniform.rs:441:31 clippy::invalid_upcast_comparisons "because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false"
+rand-0.7.3/src/distributions/uniform.rs:441:31 clippy::invalid_upcast_comparisons "because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false"
+rand-0.7.3/src/distributions/uniform.rs:441:31 clippy::invalid_upcast_comparisons "because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false"
+rand-0.7.3/src/distributions/uniform.rs:441:31 clippy::invalid_upcast_comparisons "because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false"
+rand-0.7.3/src/distributions/uniform.rs:441:31 clippy::invalid_upcast_comparisons "because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false"
+rand-0.7.3/src/distributions/uniform.rs:441:31 clippy::invalid_upcast_comparisons "because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false"
+rand-0.7.3/src/distributions/uniform.rs:441:31 clippy::invalid_upcast_comparisons "because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false"
+rand-0.7.3/src/distributions/uniform.rs:441:31 clippy::invalid_upcast_comparisons "because of the numeric bounds on `::core::u16::MAX` prior to casting, this expression is always false"
+rand-0.7.3/src/distributions/uniform.rs:56:10 clippy::doc_markdown "you should put `SampleBorrow` between ticks in the documentation"
+rand-0.7.3/src/distributions/uniform.rs:647:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand-0.7.3/src/distributions/uniform.rs:840:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand-0.7.3/src/distributions/uniform.rs:913:13 clippy::option_if_let_else "use Option::map_or_else instead of an if let/else"
+rand-0.7.3/src/distributions/uniform.rs:943:54 clippy::cast_possible_truncation "casting `u64` to `u32` may truncate the value"
+rand-0.7.3/src/distributions/unit_circle.rs:30:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand-0.7.3/src/distributions/unit_sphere.rs:24:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand-0.7.3/src/distributions/unit_sphere.rs:29:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand-0.7.3/src/distributions/utils.rs:218:18 clippy::upper_case_acronyms "name `FloatSIMDUtils` contains a capitalized acronym"
+rand-0.7.3/src/distributions/utils.rs:247:15 clippy::wrong_self_convention "methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name"
+rand-0.7.3/src/distributions/utils.rs:248:20 clippy::wrong_self_convention "methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name"
+rand-0.7.3/src/distributions/utils.rs:249:18 clippy::wrong_self_convention "methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name"
+rand-0.7.3/src/distributions/utils.rs:253:18 clippy::upper_case_acronyms "name `FloatAsSIMD` contains a capitalized acronym"
+rand-0.7.3/src/distributions/utils.rs:254:5 clippy::inline_always "you have declared `#[inline(always)]` on `lanes`. This is usually a bad idea"
+rand-0.7.3/src/distributions/utils.rs:258:5 clippy::inline_always "you have declared `#[inline(always)]` on `splat`. This is usually a bad idea"
+rand-0.7.3/src/distributions/utils.rs:262:5 clippy::inline_always "you have declared `#[inline(always)]` on `extract`. This is usually a bad idea"
+rand-0.7.3/src/distributions/utils.rs:267:5 clippy::inline_always "you have declared `#[inline(always)]` on `replace`. This is usually a bad idea"
+rand-0.7.3/src/distributions/utils.rs:274:18 clippy::upper_case_acronyms "name `BoolAsSIMD` contains a capitalized acronym"
+rand-0.7.3/src/distributions/utils.rs:281:5 clippy::inline_always "you have declared `#[inline(always)]` on `any`. This is usually a bad idea"
+rand-0.7.3/src/distributions/utils.rs:286:5 clippy::inline_always "you have declared `#[inline(always)]` on `all`. This is usually a bad idea"
+rand-0.7.3/src/distributions/utils.rs:291:5 clippy::inline_always "you have declared `#[inline(always)]` on `none`. This is usually a bad idea"
+rand-0.7.3/src/distributions/utils.rs:488:17 clippy::doc_markdown "you should put `x_i` between ticks in the documentation"
+rand-0.7.3/src/distributions/utils.rs:489:50 clippy::doc_markdown "you should put `x_i` between ticks in the documentation"
+rand-0.7.3/src/distributions/utils.rs:489:63 clippy::doc_markdown "you should put `f(x_i` between ticks in the documentation"
+rand-0.7.3/src/distributions/utils.rs:490:40 clippy::doc_markdown "you should put `f(x_i` between ticks in the documentation"
+rand-0.7.3/src/distributions/utils.rs:490:49 clippy::doc_markdown "you should put `f(x_{i+1` between ticks in the documentation"
+rand-0.7.3/src/distributions/utils.rs:518:17 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
+rand-0.7.3/src/distributions/weibull.rs:29:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand-0.7.3/src/distributions/weighted/alias_method.rs:113:21 clippy::explicit_iter_loop "it is more concise to loop over references to containers instead of using explicit iteration methods"
+rand-0.7.3/src/distributions/weighted/alias_method.rs:125:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rand-0.7.3/src/distributions/weighted/alias_method.rs:131:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rand-0.7.3/src/distributions/weighted/alias_method.rs:180:36 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+rand-0.7.3/src/distributions/weighted/alias_method.rs:182:34 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+rand-0.7.3/src/distributions/weighted/alias_method.rs:259:28 clippy::clone_on_copy "using `clone` on type `distributions::uniform::Uniform<u32>` which implements the `Copy` trait"
+rand-0.7.3/src/distributions/weighted/alias_method.rs:296:9 clippy::map_clone "you are using an explicit closure for copying elements"
+rand-0.7.3/src/distributions/weighted/alias_method.rs:321:9 clippy::map_clone "you are using an explicit closure for copying elements"
+rand-0.7.3/src/distributions/weighted/alias_method.rs:78:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+rand-0.7.3/src/distributions/weighted/alias_method.rs:78:5 clippy::too_many_lines "this function has too many lines (106/100)"
+rand-0.7.3/src/distributions/weighted/alias_method.rs:85:17 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+rand-0.7.3/src/distributions/weighted/alias_method.rs:87:31 clippy::map_unwrap_or "called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead"
+rand-0.7.3/src/distributions/weighted/mod.rs:100:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+rand-0.7.3/src/distributions/weighted/mod.rs:144:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+rand-0.7.3/src/distributions/weighted/mod.rs:169:16 clippy::int_plus_one "unnecessary `>= y + 1` or `x - 1 >=`"
+rand-0.7.3/src/distributions/weighted/mod.rs:386:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand-0.7.3/src/distributions/weighted/mod.rs:85:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand-0.7.3/src/lib.rs:333:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+rand-0.7.3/src/lib.rs:404:14 clippy::wrong_self_convention "methods called `to_*` usually take self by reference; consider choosing a less ambiguous name"
+rand-0.7.3/src/lib.rs:552:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+rand-0.7.3/src/rngs/adapter/read.rs:47:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand-0.7.3/src/rngs/adapter/read.rs:89:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand-0.7.3/src/rngs/adapter/reseeding.rs:100:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+rand-0.7.3/src/rngs/adapter/reseeding.rs:112:5 clippy::inline_always "you have declared `#[inline(always)]` on `next_u32`. This is usually a bad idea"
+rand-0.7.3/src/rngs/adapter/reseeding.rs:117:5 clippy::inline_always "you have declared `#[inline(always)]` on `next_u64`. This is usually a bad idea"
+rand-0.7.3/src/rngs/adapter/reseeding.rs:198:13 clippy::cast_possible_wrap "casting `u64` to `i64` may wrap around the value"
+rand-0.7.3/src/rngs/adapter/reseeding.rs:231:9 clippy::cast_possible_wrap "casting `usize` to `isize` may wrap around the value"
+rand-0.7.3/src/rngs/adapter/reseeding.rs:27:28 clippy::doc_markdown "you should put `ChaCha` between ticks in the documentation"
+rand-0.7.3/src/rngs/adapter/reseeding.rs:79:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand-0.7.3/src/rngs/entropy.rs:24:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand-0.7.3/src/rngs/entropy.rs:34:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand-0.7.3/src/rngs/mock.rs:36:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand-0.7.3/src/rngs/mock.rs:47:9 clippy::cast_possible_truncation "casting `u64` to `u32` may truncate the value"
+rand-0.7.3/src/rngs/mod.rs:61:74 clippy::doc_markdown "you should put `ChaCha20` between ticks in the documentation"
+rand-0.7.3/src/rngs/std.rs:25:39 clippy::doc_markdown "you should put `ChaCha` between ticks in the documentation"
+rand-0.7.3/src/rngs/std.rs:32:10 clippy::doc_markdown "you should put `rand_chacha` between ticks in the documentation"
+rand-0.7.3/src/rngs/std.rs:36:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand-0.7.3/src/rngs/std.rs:39:5 clippy::inline_always "you have declared `#[inline(always)]` on `next_u32`. This is usually a bad idea"
+rand-0.7.3/src/rngs/std.rs:44:5 clippy::inline_always "you have declared `#[inline(always)]` on `next_u64`. This is usually a bad idea"
+rand-0.7.3/src/rngs/std.rs:49:5 clippy::inline_always "you have declared `#[inline(always)]` on `fill_bytes`. This is usually a bad idea"
+rand-0.7.3/src/rngs/std.rs:54:5 clippy::inline_always "you have declared `#[inline(always)]` on `try_fill_bytes`. This is usually a bad idea"
+rand-0.7.3/src/rngs/std.rs:63:5 clippy::inline_always "you have declared `#[inline(always)]` on `from_seed`. This is usually a bad idea"
+rand-0.7.3/src/rngs/std.rs:68:5 clippy::inline_always "you have declared `#[inline(always)]` on `from_rng`. This is usually a bad idea"
+rand-0.7.3/src/rngs/thread.rs:57:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand-0.7.3/src/rngs/thread.rs:80:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand-0.7.3/src/rngs/thread.rs:80:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+rand-0.7.3/src/rngs/thread.rs:81:35 clippy::redundant_closure_for_method_calls "redundant closure found"
+rand-0.7.3/src/rngs/thread.rs:93:5 clippy::inline_always "you have declared `#[inline(always)]` on `next_u32`. This is usually a bad idea"
+rand-0.7.3/src/rngs/thread.rs:98:5 clippy::inline_always "you have declared `#[inline(always)]` on `next_u64`. This is usually a bad idea"
+rand-0.7.3/src/seq/index.rs:127:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand-0.7.3/src/seq/index.rs:139:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+rand-0.7.3/src/seq/index.rs:159:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand-0.7.3/src/seq/index.rs:171:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+rand-0.7.3/src/seq/index.rs:180:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+rand-0.7.3/src/seq/index.rs:223:18 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+rand-0.7.3/src/seq/index.rs:224:18 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+rand-0.7.3/src/seq/index.rs:233:25 clippy::cast_precision_loss "casting `u32` to `f32` causes a loss of precision (`u32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)"
+rand-0.7.3/src/seq/index.rs:236:27 clippy::cast_precision_loss "casting `u32` to `f32` causes a loss of precision (`u32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)"
+rand-0.7.3/src/seq/index.rs:244:12 clippy::cast_precision_loss "casting `u32` to `f32` causes a loss of precision (`u32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)"
+rand-0.7.3/src/seq/index.rs:244:37 clippy::cast_precision_loss "casting `u32` to `f32` causes a loss of precision (`u32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)"
+rand-0.7.3/src/seq/index.rs:29:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand-0.7.3/src/seq/index.rs:39:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand-0.7.3/src/seq/index.rs:48:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand-0.7.3/src/seq/index.rs:60:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand-0.7.3/src/seq/index.rs:69:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand-0.7.3/src/seq/index.rs:78:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand-0.7.3/src/seq/index.rs:87:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand-0.7.3/src/seq/index.rs:87:5 clippy::should_implement_trait "method `into_iter` can be confused for the standard trait method `std::iter::IntoIterator::into_iter`"
+rand-0.7.3/src/seq/index.rs:97:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+rand-0.7.3/src/seq/mod.rs:141:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+rand-0.7.3/src/seq/mod.rs:168:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+rand-0.7.3/src/seq/mod.rs:229:4 clippy::needless_doctest_main "needless `fn main` in doctest"
+rand-0.7.3/src/seq/mod.rs:292:29 clippy::cast_precision_loss "casting `usize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`usize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+rand-0.7.3/src/seq/mod.rs:410:23 clippy::default_trait_access "calling `std::marker::PhantomData::default()` is more clear than this expression"
+rand-0.7.3/src/seq/mod.rs:45:4 clippy::needless_doctest_main "needless `fn main` in doctest"
+rand-0.7.3/src/seq/mod.rs:527:26 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+rand_core-0.6.0/src/block.rs:117:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand_core-0.6.0/src/block.rs:153:5 clippy::inline_always "you have declared `#[inline(always)]` on `index`. This is usually a bad idea"
+rand_core-0.6.0/src/block.rs:230:5 clippy::inline_always "you have declared `#[inline(always)]` on `try_fill_bytes`. This is usually a bad idea"
+rand_core-0.6.0/src/block.rs:240:5 clippy::inline_always "you have declared `#[inline(always)]` on `from_seed`. This is usually a bad idea"
+rand_core-0.6.0/src/block.rs:245:5 clippy::inline_always "you have declared `#[inline(always)]` on `seed_from_u64`. This is usually a bad idea"
+rand_core-0.6.0/src/block.rs:250:5 clippy::inline_always "you have declared `#[inline(always)]` on `from_rng`. This is usually a bad idea"
+rand_core-0.6.0/src/block.rs:280:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand_core-0.6.0/src/block.rs:319:5 clippy::inline_always "you have declared `#[inline(always)]` on `index`. This is usually a bad idea"
+rand_core-0.6.0/src/block.rs:405:5 clippy::inline_always "you have declared `#[inline(always)]` on `try_fill_bytes`. This is usually a bad idea"
+rand_core-0.6.0/src/block.rs:415:5 clippy::inline_always "you have declared `#[inline(always)]` on `from_seed`. This is usually a bad idea"
+rand_core-0.6.0/src/block.rs:420:5 clippy::inline_always "you have declared `#[inline(always)]` on `seed_from_u64`. This is usually a bad idea"
+rand_core-0.6.0/src/block.rs:425:5 clippy::inline_always "you have declared `#[inline(always)]` on `from_rng`. This is usually a bad idea"
+rand_core-0.6.0/src/block.rs:67:14 clippy::doc_markdown "you should put `module][crate::block` between ticks in the documentation"
+rand_core-0.6.0/src/block.rs:68:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rand_core-0.6.0/src/error.rs:106:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand_core-0.6.0/src/error.rs:87:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand_core-0.6.0/src/error.rs:95:74 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
+rand_core-0.6.0/src/lib.rs:179:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+rand_core-0.6.0/src/lib.rs:301:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rand_core-0.6.0/src/lib.rs:303:26 clippy::unreadable_literal "long literal lacking separators"
+rand_core-0.6.0/src/lib.rs:304:26 clippy::unreadable_literal "long literal lacking separators"
+rand_core-0.6.0/src/lib.rs:313:30 clippy::cast_possible_truncation "casting `u64` to `u32` may truncate the value"
+rand_core-0.6.0/src/lib.rs:314:23 clippy::cast_possible_truncation "casting `u64` to `u32` may truncate the value"
+rand_core-0.6.0/src/lib.rs:346:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+rand_core-0.6.0/src/lib.rs:381:5 clippy::inline_always "you have declared `#[inline(always)]` on `next_u32`. This is usually a bad idea"
+rand_core-0.6.0/src/lib.rs:386:5 clippy::inline_always "you have declared `#[inline(always)]` on `next_u64`. This is usually a bad idea"
+rand_core-0.6.0/src/lib.rs:391:5 clippy::inline_always "you have declared `#[inline(always)]` on `fill_bytes`. This is usually a bad idea"
+rand_core-0.6.0/src/lib.rs:396:5 clippy::inline_always "you have declared `#[inline(always)]` on `try_fill_bytes`. This is usually a bad idea"
+rayon-1.5.0/src/collections/binary_heap.rs:7:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/collections/binary_heap.rs:8:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/collections/btree_map.rs:7:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/collections/btree_map.rs:8:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/collections/btree_set.rs:7:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/collections/btree_set.rs:8:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/collections/hash_map.rs:10:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/collections/hash_map.rs:9:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/collections/hash_set.rs:10:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/collections/hash_set.rs:9:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/collections/linked_list.rs:7:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/collections/linked_list.rs:8:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/collections/mod.rs:59:32 clippy::mem_replace_with_default "replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`"
+rayon-1.5.0/src/collections/vec_deque.rs:8:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/collections/vec_deque.rs:9:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/compile_fail/cannot_collect_filtermap_data.rs:2:1 clippy::needless_doctest_main "needless `fn main` in doctest"
+rayon-1.5.0/src/compile_fail/cannot_zip_filtered_data.rs:2:1 clippy::needless_doctest_main "needless `fn main` in doctest"
+rayon-1.5.0/src/compile_fail/cell_par_iter.rs:2:1 clippy::needless_doctest_main "needless `fn main` in doctest"
+rayon-1.5.0/src/compile_fail/no_send_par_iter.rs:25:1 clippy::needless_doctest_main "needless `fn main` in doctest"
+rayon-1.5.0/src/compile_fail/no_send_par_iter.rs:46:1 clippy::needless_doctest_main "needless `fn main` in doctest"
+rayon-1.5.0/src/compile_fail/no_send_par_iter.rs:4:1 clippy::needless_doctest_main "needless `fn main` in doctest"
+rayon-1.5.0/src/compile_fail/rc_par_iter.rs:2:1 clippy::needless_doctest_main "needless `fn main` in doctest"
+rayon-1.5.0/src/iter/chain.rs:103:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/chain.rs:122:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/chain.rs:128:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/chain.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/chain.rs:221:36 clippy::doc_markdown "you should put `ExactSizeIterator` between ticks in the documentation"
+rayon-1.5.0/src/iter/chain.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/chain.rs:51:38 clippy::option_if_let_else "use Option::map_or_else instead of an if let/else"
+rayon-1.5.0/src/iter/chain.rs:58:14 clippy::shadow_unrelated "`a` is being shadowed"
+rayon-1.5.0/src/iter/chain.rs:58:17 clippy::shadow_unrelated "`b` is being shadowed"
+rayon-1.5.0/src/iter/chain.rs:78:14 clippy::shadow_unrelated "`a` is being shadowed"
+rayon-1.5.0/src/iter/chain.rs:78:17 clippy::shadow_unrelated "`b` is being shadowed"
+rayon-1.5.0/src/iter/chain.rs:97:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/chunks.rs:3:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/chunks.rs:4:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/chunks.rs:77:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/chunks.rs:83:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/cloned.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/cloned.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/cloned.rs:71:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/cloned.rs:75:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/collect/consumer.rs:141:5 clippy::doc_markdown "you should put `CollectReducer` between ticks in the documentation"
+rayon-1.5.0/src/iter/collect/consumer.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/collect/consumer.rs:28:5 clippy::doc_markdown "you should put `CollectResult` between ticks in the documentation"
+rayon-1.5.0/src/iter/collect/consumer.rs:36:37 clippy::mut_mut "generally you want to avoid `&mut &mut _` if possible"
+rayon-1.5.0/src/iter/collect/consumer.rs:36:37 clippy::mut_mut "generally you want to avoid `&mut &mut _` if possible"
+rayon-1.5.0/src/iter/collect/mod.rs:154:9 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+rayon-1.5.0/src/iter/copied.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/copied.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/copied.rs:71:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/copied.rs:75:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/empty.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/empty.rs:24:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+rayon-1.5.0/src/iter/empty.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/enumerate.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/enumerate.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/enumerate.rs:64:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/enumerate.rs:68:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/extend.rs:143:63 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
+rayon-1.5.0/src/iter/extend.rs:182:57 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
+rayon-1.5.0/src/iter/extend.rs:218:32 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
+rayon-1.5.0/src/iter/extend.rs:218:59 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
+rayon-1.5.0/src/iter/extend.rs:25:42 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
+rayon-1.5.0/src/iter/extend.rs:287:62 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
+rayon-1.5.0/src/iter/extend.rs:322:56 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
+rayon-1.5.0/src/iter/extend.rs:41:27 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
+rayon-1.5.0/src/iter/extend.rs:47:30 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
+rayon-1.5.0/src/iter/extend.rs:47:56 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
+rayon-1.5.0/src/iter/extend.rs:47:74 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
+rayon-1.5.0/src/iter/extend.rs:53:29 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
+rayon-1.5.0/src/iter/extend.rs:57:36 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
+rayon-1.5.0/src/iter/extend.rs:59:61 clippy::linkedlist "I see you're using a LinkedList! Perhaps you meant some other data structure?"
+rayon-1.5.0/src/iter/filter.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/filter.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/filter_map.rs:123:9 clippy::option_if_let_else "use Option::map_or instead of an if let/else"
+rayon-1.5.0/src/iter/filter_map.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/filter_map.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/find.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/find.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/find_first_last/mod.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/find_first_last/mod.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/find_first_last/mod.rs:32:67 clippy::doc_markdown "you should put `MatchPosition` between ticks in the documentation"
+rayon-1.5.0/src/iter/flat_map.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/flat_map.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/flat_map_iter.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/flat_map_iter.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/flatten.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/flatten.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/flatten_iter.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/flatten_iter.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/fold.rs:158:13 clippy::similar_names "binding's name is too similar to existing binding"
+rayon-1.5.0/src/iter/fold.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/fold.rs:204:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rayon-1.5.0/src/iter/fold.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/for_each.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/for_each.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/inspect.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/inspect.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/inspect.rs:83:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/inspect.rs:88:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/interleave.rs:111:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/interleave.rs:119:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/interleave.rs:195:30 clippy::doc_markdown "you should put `self.i_len` between ticks in the documentation"
+rayon-1.5.0/src/iter/interleave.rs:195:43 clippy::doc_markdown "you should put `self.j_len` between ticks in the documentation"
+rayon-1.5.0/src/iter/interleave.rs:199:23 clippy::doc_markdown "you should put `self.i_len` between ticks in the documentation"
+rayon-1.5.0/src/iter/interleave.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/interleave.rs:200:23 clippy::doc_markdown "you should put `self.j_len` between ticks in the documentation"
+rayon-1.5.0/src/iter/interleave.rs:249:41 clippy::doc_markdown "you should put `DoubleEndedIterator` between ticks in the documentation"
+rayon-1.5.0/src/iter/interleave.rs:250:5 clippy::doc_markdown "you should put `ExactSizeIterator` between ticks in the documentation"
+rayon-1.5.0/src/iter/interleave.rs:263:33 clippy::doc_markdown "you should put `InterleaveSeq` between ticks in the documentation"
+rayon-1.5.0/src/iter/interleave.rs:280:17 clippy::match_wildcard_for_single_variants "wildcard match will miss any future added variants"
+rayon-1.5.0/src/iter/interleave.rs:285:17 clippy::match_wildcard_for_single_variants "wildcard match will miss any future added variants"
+rayon-1.5.0/src/iter/interleave.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/interleave.rs:313:9 clippy::comparison_chain "`if` chain can be rewritten with `match`"
+rayon-1.5.0/src/iter/interleave.rs:82:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/interleave.rs:90:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/interleave_shortest.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/intersperse.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/intersperse.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/intersperse.rs:90:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/intersperse.rs:96:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/len.rs:12:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+rayon-1.5.0/src/iter/len.rs:146:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+rayon-1.5.0/src/iter/len.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/len.rs:200:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/len.rs:205:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/len.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/len.rs:66:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/len.rs:71:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/map.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/map.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/map.rs:84:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/map.rs:89:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/map_with.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/map_with.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/map_with.rs:419:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/map_with.rs:425:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/map_with.rs:90:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/map_with.rs:96:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/mod.rs:1874:24 clippy::trivially_copy_pass_by_ref "this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+rayon-1.5.0/src/iter/mod.rs:2171:1 clippy::len_without_is_empty "trait `IndexedParallelIterator` has a `len` method but no (possibly inherited) `is_empty` method"
+rayon-1.5.0/src/iter/mod.rs:2371:26 clippy::trivially_copy_pass_by_ref "this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+rayon-1.5.0/src/iter/mod.rs:2411:26 clippy::trivially_copy_pass_by_ref "this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+rayon-1.5.0/src/iter/mod.rs:82:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/multizip.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/multizip.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/noop.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/once.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/once.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/panic_fuse.rs:102:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/panic_fuse.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/panic_fuse.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/panic_fuse.rs:98:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/par_bridge.rs:136:28 clippy::redundant_else "redundant else block"
+rayon-1.5.0/src/iter/par_bridge.rs:163:28 clippy::redundant_else "redundant else block"
+rayon-1.5.0/src/iter/plumbing/mod.rs:216:58 clippy::doc_markdown "you should put `find_first` between ticks in the documentation"
+rayon-1.5.0/src/iter/plumbing/mod.rs:359:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/plumbing/mod.rs:364:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/plumbing/mod.rs:399:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/plumbing/mod.rs:53:19 clippy::doc_markdown "you should put `DoubleEndedIterator` between ticks in the documentation"
+rayon-1.5.0/src/iter/plumbing/mod.rs:53:43 clippy::doc_markdown "you should put `ExactSizeIterator` between ticks in the documentation"
+rayon-1.5.0/src/iter/plumbing/mod.rs:54:31 clippy::doc_markdown "you should put `IntoIterator` between ticks in the documentation"
+rayon-1.5.0/src/iter/plumbing/mod.rs:55:5 clippy::doc_markdown "you should put `IntoIterator` between ticks in the documentation"
+rayon-1.5.0/src/iter/positions.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/positions.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/product.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/reduce.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/repeat.rs:103:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rayon-1.5.0/src/iter/repeat.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/repeat.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/rev.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/rev.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/rev.rs:63:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/rev.rs:68:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/skip.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/skip.rs:3:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/skip.rs:68:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/skip.rs:73:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/splitter.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/splitter.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/step_by.rs:4:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/step_by.rs:5:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/step_by.rs:73:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/step_by.rs:79:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/sum.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/take.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/take.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/take.rs:67:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/take.rs:72:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/try_fold.rs:190:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rayon-1.5.0/src/iter/try_fold.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/try_fold.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/try_reduce.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/try_reduce_with.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/unzip.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/unzip.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/update.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/update.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/update.rs:82:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/update.rs:87:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/while_some.rs:130:22 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+rayon-1.5.0/src/iter/while_some.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/while_some.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/zip.rs:102:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/zip.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/zip.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/zip.rs:74:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/zip.rs:79:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/zip.rs:97:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/iter/zip_eq.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/iter/zip_eq.rs:2:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/option.rs:8:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/option.rs:9:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/par_either.rs:1:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/par_either.rs:3:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/private.rs:9:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+rayon-1.5.0/src/range.rs:19:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/range.rs:20:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/range_inclusive.rs:194:9 clippy::range_plus_one "an inclusive range would be more readable"
+rayon-1.5.0/src/range_inclusive.rs:194:9 clippy::range_plus_one "an inclusive range would be more readable"
+rayon-1.5.0/src/range_inclusive.rs:19:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/range_inclusive.rs:209:9 clippy::range_plus_one "an inclusive range would be more readable"
+rayon-1.5.0/src/range_inclusive.rs:209:9 clippy::range_plus_one "an inclusive range would be more readable"
+rayon-1.5.0/src/range_inclusive.rs:20:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/range_inclusive.rs:231:9 clippy::range_plus_one "an inclusive range would be more readable"
+rayon-1.5.0/src/range_inclusive.rs:231:9 clippy::range_plus_one "an inclusive range would be more readable"
+rayon-1.5.0/src/result.rs:8:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/result.rs:9:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/slice/mergesort.rs:102:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/slice/mergesort.rs:109:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/slice/mergesort.rs:114:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/slice/mergesort.rs:211:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/slice/mergesort.rs:217:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/slice/mergesort.rs:251:5 clippy::doc_markdown "you should put `TimSort` between ticks in the documentation"
+rayon-1.5.0/src/slice/mergesort.rs:252:5 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
+rayon-1.5.0/src/slice/mergesort.rs:286:59 clippy::doc_markdown "you should put `TimSort` between ticks in the documentation"
+rayon-1.5.0/src/slice/mergesort.rs:333:24 clippy::redundant_else "redundant else block"
+rayon-1.5.0/src/slice/mergesort.rs:513:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/slice/mergesort.rs:521:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/slice/mergesort.rs:7:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/slice/mergesort.rs:98:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/slice/mod.rs:15:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/slice/mod.rs:16:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/slice/mod.rs:17:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/slice/mod.rs:25:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+rayon-1.5.0/src/slice/mod.rs:657:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rayon-1.5.0/src/slice/mod.rs:971:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+rayon-1.5.0/src/slice/quicksort.rs:230:36 clippy::doc_markdown "you should put `BlockQuicksort` between ticks in the documentation"
+rayon-1.5.0/src/slice/quicksort.rs:233:1 clippy::too_many_lines "this function has too many lines (117/100)"
+rayon-1.5.0/src/slice/quicksort.rs:258:26 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+rayon-1.5.0/src/slice/quicksort.rs:265:26 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+rayon-1.5.0/src/slice/quicksort.rs:268:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+rayon-1.5.0/src/slice/quicksort.rs:308:30 clippy::cast_possible_truncation "casting `usize` to `u8` may truncate the value"
+rayon-1.5.0/src/slice/quicksort.rs:325:30 clippy::cast_possible_truncation "casting `usize` to `u8` may truncate the value"
+rayon-1.5.0/src/slice/quicksort.rs:393:36 clippy::cast_possible_wrap "casting `u8` to `isize` may wrap around the value on targets with 32-bit wide pointers"
+rayon-1.5.0/src/slice/quicksort.rs:405:40 clippy::cast_possible_wrap "casting `u8` to `isize` may wrap around the value on targets with 32-bit wide pointers"
+rayon-1.5.0/src/slice/quicksort.rs:430:14 clippy::shadow_unrelated "`pivot` is being shadowed"
+rayon-1.5.0/src/slice/quicksort.rs:439:13 clippy::shadow_unrelated "`pivot` is being shadowed"
+rayon-1.5.0/src/slice/quicksort.rs:482:10 clippy::shadow_unrelated "`pivot` is being shadowed"
+rayon-1.5.0/src/slice/quicksort.rs:491:9 clippy::shadow_unrelated "`pivot` is being shadowed"
+rayon-1.5.0/src/slice/quicksort.rs:534:26 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+rayon-1.5.0/src/slice/quicksort.rs:545:17 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
+rayon-1.5.0/src/slice/quicksort.rs:588:17 clippy::identity_op "the operation is ineffective. Consider reducing it to `len / 4`"
+rayon-1.5.0/src/slice/quicksort.rs:716:14 clippy::shadow_unrelated "`pivot` is being shadowed"
+rayon-1.5.0/src/split_producer.rs:56:16 clippy::option_if_let_else "use Option::map_or_else instead of an if let/else"
+rayon-1.5.0/src/split_producer.rs:92:9 clippy::option_if_let_else "use Option::map_or instead of an if let/else"
+rayon-1.5.0/src/str.rs:16:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/str.rs:17:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/str.rs:18:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/str.rs:25:5 clippy::cast_possible_wrap "casting `u8` to `i8` may wrap around the value"
+rayon-1.5.0/src/str.rs:715:9 clippy::manual_strip "stripping a suffix manually"
+rayon-1.5.0/src/string.rs:5:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/vec.rs:137:12 clippy::len_zero "length comparison to zero"
+rayon-1.5.0/src/vec.rs:8:5 clippy::wildcard_imports "usage of wildcard import"
+rayon-1.5.0/src/vec.rs:9:5 clippy::wildcard_imports "usage of wildcard import"
+regex-1.3.2/src/backtrack.rs:100:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/backtrack.rs:133:17 clippy::same_item_push "it looks like the same item is being pushed into this Vec"
+regex-1.3.2/src/backtrack.rs:145:20 clippy::if_not_else "unnecessary boolean `not` operation"
+regex-1.3.2/src/backtrack.rs:199:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex-1.3.2/src/backtrack.rs:223:29 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/backtrack.rs:230:66 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/backtrack.rs:284:21 clippy::cast_lossless "casting `u32` to `u64` may become silently lossy if you later change the type"
+regex-1.3.2/src/backtrack.rs:287:5 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+regex-1.3.2/src/backtrack.rs:97:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/backtrack.rs:98:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/backtrack.rs:99:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/compile.rs:1005:32 clippy::unreadable_literal "long literal lacking separators"
+regex-1.3.2/src/compile.rs:1006:21 clippy::unreadable_literal "long literal lacking separators"
+regex-1.3.2/src/compile.rs:1008:18 clippy::cast_lossless "casting `u8` to `u64` may become silently lossy if you later change the type"
+regex-1.3.2/src/compile.rs:1009:18 clippy::cast_lossless "casting `u8` to `u64` may become silently lossy if you later change the type"
+regex-1.3.2/src/compile.rs:1010:9 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
+regex-1.3.2/src/compile.rs:102:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/compile.rs:1037:37 clippy::cast_possible_truncation "casting `u16` to `u8` may truncate the value"
+regex-1.3.2/src/compile.rs:1037:55 clippy::cast_possible_truncation "casting `u16` to `u8` may truncate the value"
+regex-1.3.2/src/compile.rs:1040:28 clippy::cast_possible_truncation "casting `u16` to `u8` may truncate the value"
+regex-1.3.2/src/compile.rs:1040:38 clippy::cast_possible_truncation "casting `u16` to `u8` may truncate the value"
+regex-1.3.2/src/compile.rs:1051:25 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+regex-1.3.2/src/compile.rs:1071:8 clippy::cast_lossless "casting `u32` to `u64` may become silently lossy if you later change the type"
+regex-1.3.2/src/compile.rs:112:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+regex-1.3.2/src/compile.rs:154:30 clippy::redundant_closure_for_method_calls "redundant closure found"
+regex-1.3.2/src/compile.rs:156:30 clippy::redundant_closure_for_method_calls "redundant closure found"
+regex-1.3.2/src/compile.rs:185:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+regex-1.3.2/src/compile.rs:187:40 clippy::redundant_closure_for_method_calls "redundant closure found"
+regex-1.3.2/src/compile.rs:201:53 clippy::doc_markdown "you should put `MaybeInsts` between ticks in the documentation"
+regex-1.3.2/src/compile.rs:241:63 clippy::doc_markdown "you should put `c_concat` between ticks in the documentation"
+regex-1.3.2/src/compile.rs:245:5 clippy::too_many_lines "this function has too many lines (111/100)"
+regex-1.3.2/src/compile.rs:247:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex-1.3.2/src/compile.rs:373:24 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/compile.rs:373:36 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/compile.rs:378:12 clippy::if_not_else "unnecessary boolean `not` operation"
+regex-1.3.2/src/compile.rs:400:37 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/compile.rs:407:51 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/compile.rs:409:24 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/compile.rs:417:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+regex-1.3.2/src/compile.rs:42:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/compile.rs:42:5 clippy::new_without_default "you should consider adding a `Default` implementation for `compile::Compiler`"
+regex-1.3.2/src/compile.rs:444:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+regex-1.3.2/src/compile.rs:445:57 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/compile.rs:446:20 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/compile.rs:466:20 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/compile.rs:466:32 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/compile.rs:519:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex-1.3.2/src/compile.rs:55:57 clippy::doc_markdown "you should put `size_limit` between ticks in the documentation"
+regex-1.3.2/src/compile.rs:58:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/compile.rs:748:41 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/compile.rs:74:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/compile.rs:751:54 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/compile.rs:765:41 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/compile.rs:765:55 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/compile.rs:825:39 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/compile.rs:825:51 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/compile.rs:828:49 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/compile.rs:828:61 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/compile.rs:830:59 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/compile.rs:830:71 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/compile.rs:832:43 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/compile.rs:835:41 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/compile.rs:835:53 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/compile.rs:835:67 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/compile.rs:83:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/compile.rs:896:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+regex-1.3.2/src/compile.rs:905:17 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/compile.rs:953:17 clippy::doc_markdown "you should put `HashMap` between ticks in the documentation"
+regex-1.3.2/src/compile.rs:95:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/compile.rs:980:26 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+regex-1.3.2/src/compile.rs:994:44 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/compile.rs:994:54 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/dfa.rs:1007:17 clippy::similar_names "binding's name is too similar to existing binding"
+regex-1.3.2/src/dfa.rs:1010:22 clippy::similar_names "binding's name is too similar to existing binding"
+regex-1.3.2/src/dfa.rs:1059:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex-1.3.2/src/dfa.rs:1060:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex-1.3.2/src/dfa.rs:1084:38 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+regex-1.3.2/src/dfa.rs:1087:38 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+regex-1.3.2/src/dfa.rs:1090:38 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+regex-1.3.2/src/dfa.rs:1093:38 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+regex-1.3.2/src/dfa.rs:1096:38 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+regex-1.3.2/src/dfa.rs:1101:38 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+regex-1.3.2/src/dfa.rs:1104:38 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+regex-1.3.2/src/dfa.rs:1107:38 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+regex-1.3.2/src/dfa.rs:1117:30 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+regex-1.3.2/src/dfa.rs:1120:47 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+regex-1.3.2/src/dfa.rs:1121:30 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+regex-1.3.2/src/dfa.rs:1129:13 clippy::doc_markdown "you should put `is_match` between ticks in the documentation"
+regex-1.3.2/src/dfa.rs:1134:13 clippy::doc_markdown "you should put `is_match` between ticks in the documentation"
+regex-1.3.2/src/dfa.rs:1185:68 clippy::doc_markdown "you should put `is_match` between ticks in the documentation"
+regex-1.3.2/src/dfa.rs:1193:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex-1.3.2/src/dfa.rs:1244:50 clippy::doc_markdown "you should put `current_state` between ticks in the documentation"
+regex-1.3.2/src/dfa.rs:1338:58 clippy::doc_markdown "you should put `STATE_DEAD` between ticks in the documentation"
+regex-1.3.2/src/dfa.rs:1339:9 clippy::doc_markdown "you should put `STATE_UNKNOWN` between ticks in the documentation"
+regex-1.3.2/src/dfa.rs:1366:25 clippy::doc_markdown "you should put `STATE_DEAD` between ticks in the documentation"
+regex-1.3.2/src/dfa.rs:1366:46 clippy::doc_markdown "you should put `STATE_UNKNOWN` between ticks in the documentation"
+regex-1.3.2/src/dfa.rs:1367:41 clippy::inline_always "you have declared `#[inline(always)]` on `start_state`. This is usually a bad idea"
+regex-1.3.2/src/dfa.rs:1380:14 clippy::identity_op "the operation is ineffective. Consider reducing it to `(empty_flags.start as u8)`"
+regex-1.3.2/src/dfa.rs:1388:15 clippy::match_on_vec_items "indexing into a vector may panic"
+regex-1.3.2/src/dfa.rs:1412:20 clippy::unused_self "unused `self` argument"
+regex-1.3.2/src/dfa.rs:1438:9 clippy::unused_self "unused `self` argument"
+regex-1.3.2/src/dfa.rs:1472:9 clippy::doc_markdown "you should put `StatePtr` between ticks in the documentation"
+regex-1.3.2/src/dfa.rs:1490:54 clippy::cast_possible_truncation "casting `i32` to `u8` may truncate the value"
+regex-1.3.2/src/dfa.rs:1490:54 clippy::cast_sign_loss "casting `i32` to `u8` may lose the sign of the value"
+regex-1.3.2/src/dfa.rs:1521:20 clippy::doc_markdown "you should put `num_byte_classes` between ticks in the documentation"
+regex-1.3.2/src/dfa.rs:1529:41 clippy::inline_always "you have declared `#[inline(always)]` on `byte_class`. This is usually a bad idea"
+regex-1.3.2/src/dfa.rs:1537:14 clippy::doc_markdown "you should put `byte_class` between ticks in the documentation"
+regex-1.3.2/src/dfa.rs:1538:41 clippy::inline_always "you have declared `#[inline(always)]` on `u8_class`. This is usually a bad idea"
+regex-1.3.2/src/dfa.rs:1562:18 clippy::doc_markdown "you should put `STATE_START` between ticks in the documentation"
+regex-1.3.2/src/dfa.rs:1614:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/dfa.rs:1651:38 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/dfa.rs:1700:17 clippy::trivially_copy_pass_by_ref "this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+regex-1.3.2/src/dfa.rs:1701:18 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex-1.3.2/src/dfa.rs:1705:19 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex-1.3.2/src/dfa.rs:1708:16 clippy::trivially_copy_pass_by_ref "this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+regex-1.3.2/src/dfa.rs:1709:18 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex-1.3.2/src/dfa.rs:1713:19 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex-1.3.2/src/dfa.rs:1716:18 clippy::trivially_copy_pass_by_ref "this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+regex-1.3.2/src/dfa.rs:1717:18 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex-1.3.2/src/dfa.rs:1721:19 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex-1.3.2/src/dfa.rs:1727:14 clippy::cast_lossless "casting `u8` to `u16` may become silently lossy if you later change the type"
+regex-1.3.2/src/dfa.rs:1732:15 clippy::trivially_copy_pass_by_ref "this argument (2 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+regex-1.3.2/src/dfa.rs:1736:22 clippy::trivially_copy_pass_by_ref "this argument (2 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+regex-1.3.2/src/dfa.rs:1741:9 clippy::match_like_matches_macro "match expression looks like `matches!` macro"
+regex-1.3.2/src/dfa.rs:1747:16 clippy::trivially_copy_pass_by_ref "this argument (2 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+regex-1.3.2/src/dfa.rs:1751:18 clippy::cast_possible_truncation "casting `u16` to `u8` may truncate the value"
+regex-1.3.2/src/dfa.rs:1815:38 clippy::cast_possible_truncation "casting `usize` to `u8` may truncate the value"
+regex-1.3.2/src/dfa.rs:1821:21 clippy::cast_lossless "casting `u32` to `u64` may become silently lossy if you later change the type"
+regex-1.3.2/src/dfa.rs:1824:5 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+regex-1.3.2/src/dfa.rs:1848:5 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
+regex-1.3.2/src/dfa.rs:1850:18 clippy::cast_sign_loss "casting `i32` to `u32` may lose the sign of the value"
+regex-1.3.2/src/dfa.rs:1857:5 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
+regex-1.3.2/src/dfa.rs:1860:17 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
+regex-1.3.2/src/dfa.rs:1867:5 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
+regex-1.3.2/src/dfa.rs:1870:19 clippy::cast_possible_truncation "casting `u32` to `u8` may truncate the value"
+regex-1.3.2/src/dfa.rs:1873:15 clippy::cast_possible_truncation "casting `u32` to `u8` may truncate the value"
+regex-1.3.2/src/dfa.rs:1876:5 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
+regex-1.3.2/src/dfa.rs:1882:26 clippy::cast_lossless "casting `u8` to `u32` may become silently lossy if you later change the type"
+regex-1.3.2/src/dfa.rs:1884:15 clippy::cast_lossless "casting `u8` to `u32` may become silently lossy if you later change the type"
+regex-1.3.2/src/dfa.rs:277:17 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
+regex-1.3.2/src/dfa.rs:277:31 clippy::cast_possible_wrap "casting `u32` to `i32` may wrap around the value"
+regex-1.3.2/src/dfa.rs:295:20 clippy::cast_possible_truncation "casting `usize` to `i32` may truncate the value on targets with 64-bit wide pointers"
+regex-1.3.2/src/dfa.rs:295:20 clippy::cast_possible_wrap "casting `usize` to `i32` may wrap around the value on targets with 32-bit wide pointers"
+regex-1.3.2/src/dfa.rs:299:21 clippy::cast_sign_loss "casting `i32` to `usize` may lose the sign of the value"
+regex-1.3.2/src/dfa.rs:34:46 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
+regex-1.3.2/src/dfa.rs:398:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+regex-1.3.2/src/dfa.rs:446:41 clippy::inline_always "you have declared `#[inline(always)]` on `forward`. This is usually a bad idea"
+regex-1.3.2/src/dfa.rs:457:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/dfa.rs:459:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/dfa.rs:460:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/dfa.rs:476:41 clippy::inline_always "you have declared `#[inline(always)]` on `reverse`. This is usually a bad idea"
+regex-1.3.2/src/dfa.rs:487:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/dfa.rs:489:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/dfa.rs:490:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/dfa.rs:506:41 clippy::inline_always "you have declared `#[inline(always)]` on `forward_many`. This is usually a bad idea"
+regex-1.3.2/src/dfa.rs:518:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/dfa.rs:520:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/dfa.rs:554:41 clippy::inline_always "you have declared `#[inline(always)]` on `exec_at`. This is usually a bad idea"
+regex-1.3.2/src/dfa.rs:555:5 clippy::too_many_lines "this function has too many lines (101/100)"
+regex-1.3.2/src/dfa.rs:58:9 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex-1.3.2/src/dfa.rs:667:21 clippy::similar_names "binding's name is too similar to existing binding"
+regex-1.3.2/src/dfa.rs:747:41 clippy::inline_always "you have declared `#[inline(always)]` on `exec_at_reverse`. This is usually a bad idea"
+regex-1.3.2/src/dfa.rs:795:21 clippy::similar_names "binding's name is too similar to existing binding"
+regex-1.3.2/src/dfa.rs:848:9 clippy::doc_markdown "you should put `next_si` between ticks in the documentation"
+regex-1.3.2/src/dfa.rs:852:41 clippy::inline_always "you have declared `#[inline(always)]` on `next_si`. This is usually a bad idea"
+regex-1.3.2/src/dfa.rs:885:12 clippy::doc_markdown "you should put `STATE_DEAD` between ticks in the documentation"
+regex-1.3.2/src/dfa.rs:889:9 clippy::doc_markdown "you should put `STATE_UNKNOWN` between ticks in the documentation"
+regex-1.3.2/src/dfa.rs:897:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex-1.3.2/src/dfa.rs:979:29 clippy::cast_possible_truncation "casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers"
+regex-1.3.2/src/error.rs:6:1 clippy::manual_non_exhaustive "this seems like a manual implementation of the non-exhaustive pattern"
+regex-1.3.2/src/exec.rs:1000:14 clippy::doc_markdown "you should put `captures_nfa` between ticks in the documentation"
+regex-1.3.2/src/exec.rs:100:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+regex-1.3.2/src/exec.rs:1028:5 clippy::too_many_arguments "this function has too many arguments (9/7)"
+regex-1.3.2/src/exec.rs:1039:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex-1.3.2/src/exec.rs:1144:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex-1.3.2/src/exec.rs:1179:26 clippy::match_same_arms "this `match` has identical arm bodies"
+regex-1.3.2/src/exec.rs:122:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/exec.rs:1250:41 clippy::inline_always "you have declared `#[inline(always)]` on `searcher`. This is usually a bad idea"
+regex-1.3.2/src/exec.rs:1260:41 clippy::inline_always "you have declared `#[inline(always)]` on `searcher_str`. This is usually a bad idea"
+regex-1.3.2/src/exec.rs:1270:17 clippy::doc_markdown "you should put `RegexSet` between ticks in the documentation"
+regex-1.3.2/src/exec.rs:1280:17 clippy::doc_markdown "you should put `RegexSet` between ticks in the documentation"
+regex-1.3.2/src/exec.rs:137:9 clippy::field_reassign_with_default "field assignment outside of initializer for an instance created with Default::default()"
+regex-1.3.2/src/exec.rs:142:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/exec.rs:1493:5 clippy::upper_case_acronyms "name `PikeVM` contains a capitalized acronym"
+regex-1.3.2/src/exec.rs:158:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/exec.rs:168:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/exec.rs:181:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/exec.rs:195:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/exec.rs:204:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/exec.rs:210:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/exec.rs:245:62 clippy::if_same_then_else "this `if` has identical blocks"
+regex-1.3.2/src/exec.rs:251:21 clippy::if_not_else "unnecessary boolean `not` operation"
+regex-1.3.2/src/exec.rs:262:60 clippy::if_same_then_else "this `if` has identical blocks"
+regex-1.3.2/src/exec.rs:268:21 clippy::if_not_else "unnecessary boolean `not` operation"
+regex-1.3.2/src/exec.rs:278:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/exec.rs:281:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/exec.rs:286:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+regex-1.3.2/src/exec.rs:300:30 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/exec.rs:308:17 clippy::similar_names "binding's name is too similar to existing binding"
+regex-1.3.2/src/exec.rs:329:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/exec.rs:330:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/exec.rs:331:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/exec.rs:334:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/exec.rs:340:19 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/exec.rs:344:27 clippy::unused_self "unused `self` argument"
+regex-1.3.2/src/exec.rs:383:41 clippy::inline_always "you have declared `#[inline(always)]` on `shortest_match_at`. This is usually a bad idea"
+regex-1.3.2/src/exec.rs:388:41 clippy::inline_always "you have declared `#[inline(always)]` on `is_match_at`. This is usually a bad idea"
+regex-1.3.2/src/exec.rs:393:41 clippy::inline_always "you have declared `#[inline(always)]` on `find_at`. This is usually a bad idea"
+regex-1.3.2/src/exec.rs:398:41 clippy::inline_always "you have declared `#[inline(always)]` on `captures_read_at`. This is usually a bad idea"
+regex-1.3.2/src/exec.rs:425:41 clippy::inline_always "you have declared `#[inline(always)]` on `shortest_match_at`. This is usually a bad idea"
+regex-1.3.2/src/exec.rs:44:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+regex-1.3.2/src/exec.rs:473:9 clippy::doc_markdown "you should put `shortest_match(...).is_some` between ticks in the documentation"
+regex-1.3.2/src/exec.rs:474:41 clippy::inline_always "you have declared `#[inline(always)]` on `is_match_at`. This is usually a bad idea"
+regex-1.3.2/src/exec.rs:524:41 clippy::inline_always "you have declared `#[inline(always)]` on `find_at`. This is usually a bad idea"
+regex-1.3.2/src/exec.rs:52:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+regex-1.3.2/src/exec.rs:686:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex-1.3.2/src/exec.rs:727:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex-1.3.2/src/exec.rs:767:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex-1.3.2/src/exec.rs:783:41 clippy::inline_always "you have declared `#[inline(always)]` on `shortest_dfa`. This is usually a bad idea"
+regex-1.3.2/src/exec.rs:791:41 clippy::inline_always "you have declared `#[inline(always)]` on `shortest_dfa_reverse_suffix`. This is usually a bad idea"
+regex-1.3.2/src/exec.rs:823:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex-1.3.2/src/exec.rs:868:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex-1.3.2/src/exec.rs:897:31 clippy::doc_markdown "you should put `shortest_nfa(...).is_some` between ticks in the documentation"
+regex-1.3.2/src/exec.rs:899:9 clippy::doc_markdown "you should put `shortest_nfa` between ticks in the documentation"
+regex-1.3.2/src/exec.rs:905:14 clippy::doc_markdown "you should put `match_nfa` between ticks in the documentation"
+regex-1.3.2/src/exec.rs:930:14 clippy::doc_markdown "you should put `shortest_nfa` between ticks in the documentation"
+regex-1.3.2/src/exec.rs:981:14 clippy::doc_markdown "you should put `find_nfa` between ticks in the documentation"
+regex-1.3.2/src/expand.rs:170:27 clippy::trivially_copy_pass_by_ref "this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+regex-1.3.2/src/expand.rs:171:5 clippy::match_like_matches_macro "match expression looks like `matches!` macro"
+regex-1.3.2/src/expand.rs:22:13 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
+regex-1.3.2/src/expand.rs:27:23 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+regex-1.3.2/src/expand.rs:30:17 clippy::single_char_add_str "calling `push_str()` using a single-character string literal"
+regex-1.3.2/src/expand.rs:38:30 clippy::map_unwrap_or "called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead"
+regex-1.3.2/src/expand.rs:42:21 clippy::map_unwrap_or "called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead"
+regex-1.3.2/src/expand.rs:50:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+regex-1.3.2/src/expand.rs:69:23 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+regex-1.3.2/src/expand.rs:80:28 clippy::map_unwrap_or "called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead"
+regex-1.3.2/src/expand.rs:84:21 clippy::map_unwrap_or "called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead"
+regex-1.3.2/src/expand.rs:8:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+regex-1.3.2/src/input.rs:142:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+regex-1.3.2/src/input.rs:146:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/input.rs:15:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+regex-1.3.2/src/input.rs:165:31 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/input.rs:178:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex-1.3.2/src/input.rs:228:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+regex-1.3.2/src/input.rs:236:21 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/input.rs:236:33 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/input.rs:24:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/input.rs:271:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex-1.3.2/src/input.rs:29:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/input.rs:362:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/input.rs:370:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/input.rs:371:42 clippy::redundant_closure_for_method_calls "redundant closure found"
+regex-1.3.2/src/input.rs:37:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/input.rs:388:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/input.rs:42:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/input.rs:47:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/input.rs:53:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/input.rs:58:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/input.rs:63:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/lib.rs:1:null clippy::cargo_common_metadata "package `regex` is missing `package.keywords` metadata"
+regex-1.3.2/src/literal/imp.rs:101:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/literal/imp.rs:114:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/literal/imp.rs:127:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/literal/imp.rs:139:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/literal/imp.rs:144:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/literal/imp.rs:149:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/literal/imp.rs:154:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/literal/imp.rs:155:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex-1.3.2/src/literal/imp.rs:160:30 clippy::match_same_arms "this `match` has identical arm bodies"
+regex-1.3.2/src/literal/imp.rs:167:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/literal/imp.rs:168:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex-1.3.2/src/literal/imp.rs:211:20 clippy::redundant_else "redundant else block"
+regex-1.3.2/src/literal/imp.rs:239:5 clippy::upper_case_acronyms "name `AC` contains a capitalized acronym"
+regex-1.3.2/src/literal/imp.rs:276:50 clippy::match_same_arms "this `match` has identical arm bodies"
+regex-1.3.2/src/literal/imp.rs:342:41 clippy::inline_always "you have declared `#[inline(always)]` on `find`. This is usually a bad idea"
+regex-1.3.2/src/literal/imp.rs:34:5 clippy::upper_case_acronyms "name `AC` contains a capitalized acronym"
+regex-1.3.2/src/literal/imp.rs:435:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/literal/imp.rs:436:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/literal/imp.rs:437:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/literal/imp.rs:438:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/literal/imp.rs:439:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/literal/imp.rs:440:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/literal/imp.rs:455:41 clippy::inline_always "you have declared `#[inline(always)]` on `find`. This is usually a bad idea"
+regex-1.3.2/src/literal/imp.rs:46:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/literal/imp.rs:481:41 clippy::inline_always "you have declared `#[inline(always)]` on `is_suffix`. This is usually a bad idea"
+regex-1.3.2/src/literal/imp.rs:51:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/literal/imp.rs:579:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/literal/imp.rs:57:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/literal/imp.rs:580:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/literal/imp.rs:583:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/literal/imp.rs:602:9 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+regex-1.3.2/src/literal/imp.rs:622:24 clippy::redundant_else "redundant else block"
+regex-1.3.2/src/literal/imp.rs:62:18 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+regex-1.3.2/src/literal/imp.rs:637:24 clippy::redundant_else "redundant else block"
+regex-1.3.2/src/literal/imp.rs:648:9 clippy::needless_return "unneeded `return` statement"
+regex-1.3.2/src/literal/imp.rs:651:44 clippy::doc_markdown "you should put `BoyerMooreSearch` between ticks in the documentation"
+regex-1.3.2/src/literal/imp.rs:65:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/literal/imp.rs:68:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/literal/imp.rs:783:32 clippy::redundant_else "redundant else block"
+regex-1.3.2/src/literal/imp.rs:786:42 clippy::manual_saturating_arithmetic "manual saturating arithmetic"
+regex-1.3.2/src/literal/imp.rs:78:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/literal/imp.rs:84:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/literal/imp.rs:850:20 clippy::unreadable_literal "long literal lacking separators"
+regex-1.3.2/src/literal/imp.rs:85:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex-1.3.2/src/pikevm.rs:103:15 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/pikevm.rs:103:52 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/pikevm.rs:114:5 clippy::too_many_arguments "this function has too many arguments (8/7)"
+regex-1.3.2/src/pikevm.rs:117:13 clippy::similar_names "binding's name is too similar to existing binding"
+regex-1.3.2/src/pikevm.rs:124:17 clippy::similar_names "binding's name is too similar to existing binding"
+regex-1.3.2/src/pikevm.rs:220:9 clippy::doc_markdown "you should put `thread_caps` between ticks in the documentation"
+regex-1.3.2/src/pikevm.rs:222:16 clippy::doc_markdown "you should put `at_next` between ticks in the documentation"
+regex-1.3.2/src/pikevm.rs:223:9 clippy::doc_markdown "you should put `at_next` between ticks in the documentation"
+regex-1.3.2/src/pikevm.rs:224:5 clippy::too_many_arguments "this function has too many arguments (8/7)"
+regex-1.3.2/src/pikevm.rs:234:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex-1.3.2/src/pikevm.rs:303:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex-1.3.2/src/pikevm.rs:331:29 clippy::mut_mut "this expression mutably borrows a mutable reference. Consider reborrowing"
+regex-1.3.2/src/pikevm.rs:70:5 clippy::upper_case_acronyms "name `IP` contains a capitalized acronym"
+regex-1.3.2/src/pikevm.rs:88:5 clippy::too_many_arguments "this function has too many arguments (8/7)"
+regex-1.3.2/src/prog.rs:102:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/prog.rs:113:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/prog.rs:120:9 clippy::match_like_matches_macro "match expression looks like `matches!` macro"
+regex-1.3.2/src/prog.rs:128:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/prog.rs:134:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/prog.rs:141:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/prog.rs:147:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/prog.rs:164:41 clippy::inline_always "you have declared `#[inline(always)]` on `deref`. This is usually a bad idea"
+regex-1.3.2/src/prog.rs:172:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+regex-1.3.2/src/prog.rs:18:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+regex-1.3.2/src/prog.rs:236:13 clippy::write_with_newline "using `write!()` with a format string that ends in a single newline"
+regex-1.3.2/src/prog.rs:300:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/prog.rs:301:9 clippy::match_like_matches_macro "match expression looks like `matches!` macro"
+regex-1.3.2/src/prog.rs:382:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/prog.rs:409:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/prog.rs:80:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/prog.rs:80:5 clippy::new_without_default "you should consider adding a `Default` implementation for `prog::Program`"
+regex-1.3.2/src/re_builder.rs:267:17 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+regex-1.3.2/src/re_builder.rs:267:17 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+regex-1.3.2/src/re_builder.rs:4:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+regex-1.3.2/src/re_builder.rs:57:17 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/re_builder.rs:57:17 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/re_builder.rs:68:17 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+regex-1.3.2/src/re_builder.rs:68:17 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+regex-1.3.2/src/re_bytes.rs:1017:9 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
+regex-1.3.2/src/re_bytes.rs:1039:9 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
+regex-1.3.2/src/re_bytes.rs:1093:5 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
+regex-1.3.2/src/re_bytes.rs:1118:5 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
+regex-1.3.2/src/re_bytes.rs:1133:5 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
+regex-1.3.2/src/re_bytes.rs:118:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+regex-1.3.2/src/re_bytes.rs:256:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/re_bytes.rs:29:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/re_bytes.rs:35:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/re_bytes.rs:42:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/re_bytes.rs:48:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/re_bytes.rs:558:29 clippy::doc_markdown "you should put `shortest_match` between ticks in the documentation"
+regex-1.3.2/src/re_bytes.rs:55:33 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/re_bytes.rs:55:47 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/re_bytes.rs:572:29 clippy::doc_markdown "you should put `is_match` between ticks in the documentation"
+regex-1.3.2/src/re_bytes.rs:720:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/re_bytes.rs:817:5 clippy::doc_markdown "you should put `CaptureLocations` between ticks in the documentation"
+regex-1.3.2/src/re_bytes.rs:843:1 clippy::len_without_is_empty "item `re_bytes::CaptureLocations` has a public `len` method but no corresponding `is_empty` method"
+regex-1.3.2/src/re_bytes.rs:849:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/re_bytes.rs:858:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/re_bytes.rs:869:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/re_bytes.rs:891:1 clippy::len_without_is_empty "item `re_bytes::Captures<'t>` has a public `len` method but no corresponding `is_empty` method"
+regex-1.3.2/src/re_bytes.rs:911:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/re_bytes.rs:917:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/re_bytes.rs:926:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/re_bytes.rs:955:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/re_set.rs:179:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/re_set.rs:179:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/re_set.rs:251:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/re_set.rs:251:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/re_set.rs:263:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/re_set.rs:263:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/re_set.rs:268:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/re_set.rs:268:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/re_set.rs:277:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/re_set.rs:277:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/re_set.rs:94:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+regex-1.3.2/src/re_set.rs:94:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+regex-1.3.2/src/re_trait.rs:136:29 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/re_unicode.rs:1019:9 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
+regex-1.3.2/src/re_unicode.rs:1041:9 clippy::map_unwrap_or "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead"
+regex-1.3.2/src/re_unicode.rs:1088:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/re_unicode.rs:1135:5 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
+regex-1.3.2/src/re_unicode.rs:1160:5 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
+regex-1.3.2/src/re_unicode.rs:174:5 clippy::missing_errors_doc "docs for function returning `Result` missing `# Errors` section"
+regex-1.3.2/src/re_unicode.rs:21:1 clippy::must_use_candidate "this function could have a `#[must_use]` attribute"
+regex-1.3.2/src/re_unicode.rs:313:13 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/re_unicode.rs:38:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/re_unicode.rs:44:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/re_unicode.rs:51:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/re_unicode.rs:57:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/re_unicode.rs:617:29 clippy::doc_markdown "you should put `shortest_match` between ticks in the documentation"
+regex-1.3.2/src/re_unicode.rs:631:29 clippy::doc_markdown "you should put `is_match` between ticks in the documentation"
+regex-1.3.2/src/re_unicode.rs:64:33 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/re_unicode.rs:64:47 clippy::redundant_field_names "redundant field names in struct initialization"
+regex-1.3.2/src/re_unicode.rs:834:5 clippy::doc_markdown "you should put `CaptureLocations` between ticks in the documentation"
+regex-1.3.2/src/re_unicode.rs:860:1 clippy::len_without_is_empty "item `re_unicode::CaptureLocations` has a public `len` method but no corresponding `is_empty` method"
+regex-1.3.2/src/re_unicode.rs:866:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/re_unicode.rs:875:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/re_unicode.rs:886:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/re_unicode.rs:908:1 clippy::len_without_is_empty "item `re_unicode::Captures<'t>` has a public `len` method but no corresponding `is_empty` method"
+regex-1.3.2/src/re_unicode.rs:928:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/re_unicode.rs:934:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/re_unicode.rs:943:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/re_unicode.rs:972:5 clippy::must_use_candidate "this method could have a `#[must_use]` attribute"
+regex-1.3.2/src/sparse.rs:10:37 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
+regex-1.3.2/src/sparse.rs:15:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+regex-1.3.2/src/utf8.rs:100:16 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex-1.3.2/src/utf8.rs:103:16 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex-1.3.2/src/utf8.rs:106:22 clippy::cast_lossless "casting `u8` to `u32` may become silently lossy if you later change the type"
+regex-1.3.2/src/utf8.rs:107:19 clippy::cast_lossless "casting `u8` to `u32` may become silently lossy if you later change the type"
+regex-1.3.2/src/utf8.rs:108:19 clippy::cast_lossless "casting `u8` to `u32` may become silently lossy if you later change the type"
+regex-1.3.2/src/utf8.rs:109:19 clippy::cast_lossless "casting `u8` to `u32` may become silently lossy if you later change the type"
+regex-1.3.2/src/utf8.rs:111:27 clippy::unreadable_literal "long literal lacking separators"
+regex-1.3.2/src/utf8.rs:121:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+regex-1.3.2/src/utf8.rs:143:24 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex-1.3.2/src/utf8.rs:143:9 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex-1.3.2/src/utf8.rs:23:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+regex-1.3.2/src/utf8.rs:30:20 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex-1.3.2/src/utf8.rs:51:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+regex-1.3.2/src/utf8.rs:58:23 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex-1.3.2/src/utf8.rs:58:9 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex-1.3.2/src/utf8.rs:63:16 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex-1.3.2/src/utf8.rs:66:22 clippy::cast_lossless "casting `u8` to `u32` may become silently lossy if you later change the type"
+regex-1.3.2/src/utf8.rs:66:54 clippy::cast_lossless "casting `u8` to `u32` may become silently lossy if you later change the type"
+regex-1.3.2/src/utf8.rs:77:16 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex-1.3.2/src/utf8.rs:80:16 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex-1.3.2/src/utf8.rs:83:22 clippy::cast_lossless "casting `u8` to `u32` may become silently lossy if you later change the type"
+regex-1.3.2/src/utf8.rs:84:19 clippy::cast_lossless "casting `u8` to `u32` may become silently lossy if you later change the type"
+regex-1.3.2/src/utf8.rs:85:19 clippy::cast_lossless "casting `u8` to `u32` may become silently lossy if you later change the type"
+regex-1.3.2/src/utf8.rs:92:23 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex-1.3.2/src/utf8.rs:92:9 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+regex-1.3.2/src/utf8.rs:97:16 clippy::unusual_byte_groupings "digits of hex or binary literal not grouped by four"
+ripgrep-12.1.1//home/matthias/.rustup/toolchains/nightly-2021-01-15-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/std/src/macros.rs:14:27 clippy::match_same_arms "this `match` has identical arm bodies"
+ripgrep-12.1.1//home/matthias/.rustup/toolchains/nightly-2021-01-15-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/std/src/macros.rs:14:27 clippy::match_same_arms "this `match` has identical arm bodies"
+ripgrep-12.1.1//home/matthias/.rustup/toolchains/nightly-2021-01-15-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/std/src/macros.rs:14:27 clippy::match_same_arms "this `match` has identical arm bodies"
+ripgrep-12.1.1//home/matthias/.rustup/toolchains/nightly-2021-01-15-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/std/src/macros.rs:14:27 clippy::match_same_arms "this `match` has identical arm bodies"
+ripgrep-12.1.1/build.rs:133:19 clippy::option_as_ref_deref "called `.as_ref().map(|x| &**x)` on an Option value. This can be done more directly by calling `githash.as_deref()` instead"
+ripgrep-12.1.1/build.rs:18:18 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+ripgrep-12.1.1/build.rs:225:14 clippy::redundant_closure_for_method_calls "redundant closure found"
+ripgrep-12.1.1/build.rs:92:19 clippy::option_as_ref_deref "called `.as_ref().map(|x| &**x)` on an Option value. This can be done more directly by calling `githash.as_deref()` instead"
+ripgrep-12.1.1/crates/core/app.rs:1408:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+ripgrep-12.1.1/crates/core/app.rs:1408:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+ripgrep-12.1.1/crates/core/app.rs:1409:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+ripgrep-12.1.1/crates/core/app.rs:1409:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+ripgrep-12.1.1/crates/core/app.rs:152:32 clippy::doc_markdown "you should put `clap::Arg` between ticks in the documentation"
+ripgrep-12.1.1/crates/core/app.rs:152:32 clippy::doc_markdown "you should put `clap::Arg` between ticks in the documentation"
+ripgrep-12.1.1/crates/core/app.rs:156:39 clippy::doc_markdown "you should put `clap::Arg` between ticks in the documentation"
+ripgrep-12.1.1/crates/core/app.rs:156:39 clippy::doc_markdown "you should put `clap::Arg` between ticks in the documentation"
+ripgrep-12.1.1/crates/core/app.rs:156:5 clippy::doc_markdown "you should put `RGArg` between ticks in the documentation"
+ripgrep-12.1.1/crates/core/app.rs:156:5 clippy::doc_markdown "you should put `RGArg` between ticks in the documentation"
+ripgrep-12.1.1/crates/core/app.rs:164:12 clippy::upper_case_acronyms "name `RGArg` contains a capitalized acronym"
+ripgrep-12.1.1/crates/core/app.rs:164:12 clippy::upper_case_acronyms "name `RGArg` contains a capitalized acronym"
+ripgrep-12.1.1/crates/core/app.rs:1668:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+ripgrep-12.1.1/crates/core/app.rs:1668:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+ripgrep-12.1.1/crates/core/app.rs:1669:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+ripgrep-12.1.1/crates/core/app.rs:1669:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+ripgrep-12.1.1/crates/core/app.rs:1821:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+ripgrep-12.1.1/crates/core/app.rs:1821:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+ripgrep-12.1.1/crates/core/app.rs:1822:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+ripgrep-12.1.1/crates/core/app.rs:1822:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+ripgrep-12.1.1/crates/core/app.rs:212:10 clippy::upper_case_acronyms "name `RGArgKind` contains a capitalized acronym"
+ripgrep-12.1.1/crates/core/app.rs:212:10 clippy::upper_case_acronyms "name `RGArgKind` contains a capitalized acronym"
+ripgrep-12.1.1/crates/core/app.rs:2999:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+ripgrep-12.1.1/crates/core/app.rs:2999:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+ripgrep-12.1.1/crates/core/app.rs:3000:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+ripgrep-12.1.1/crates/core/app.rs:3000:5 clippy::items_after_statements "adding items after statements is confusing, since items exist from the start of the scope"
+ripgrep-12.1.1/crates/core/app.rs:367:54 clippy::match_same_arms "this `match` has identical arm bodies"
+ripgrep-12.1.1/crates/core/app.rs:367:54 clippy::match_same_arms "this `match` has identical arm bodies"
+ripgrep-12.1.1/crates/core/app.rs:414:59 clippy::match_same_arms "this `match` has identical arm bodies"
+ripgrep-12.1.1/crates/core/app.rs:414:59 clippy::match_same_arms "this `match` has identical arm bodies"
+ripgrep-12.1.1/crates/core/app.rs:417:57 clippy::match_same_arms "this `match` has identical arm bodies"
+ripgrep-12.1.1/crates/core/app.rs:417:57 clippy::match_same_arms "this `match` has identical arm bodies"
+ripgrep-12.1.1/crates/core/app.rs:417:57 clippy::match_same_arms "this `match` has identical arm bodies"
+ripgrep-12.1.1/crates/core/app.rs:417:57 clippy::match_same_arms "this `match` has identical arm bodies"
+ripgrep-12.1.1/crates/core/app.rs:75:9 clippy::doc_markdown "you should put `RIPGREP_BUILD_GIT_HASH` between ticks in the documentation"
+ripgrep-12.1.1/crates/core/app.rs:75:9 clippy::doc_markdown "you should put `RIPGREP_BUILD_GIT_HASH` between ticks in the documentation"
+ripgrep-12.1.1/crates/core/app.rs:87:5 clippy::if_not_else "unnecessary boolean `not` operation"
+ripgrep-12.1.1/crates/core/app.rs:87:5 clippy::if_not_else "unnecessary boolean `not` operation"
+ripgrep-12.1.1/crates/core/args.rs:1143:22 clippy::unused_self "unused `self` argument"
+ripgrep-12.1.1/crates/core/args.rs:11:1 clippy::single_component_path_imports "this import is redundant"
+ripgrep-12.1.1/crates/core/args.rs:1209:74 clippy::if_same_then_else "this `if` has identical blocks"
+ripgrep-12.1.1/crates/core/args.rs:1282:13 clippy::similar_names "binding's name is too similar to existing binding"
+ripgrep-12.1.1/crates/core/args.rs:1430:22 clippy::unused_self "unused `self` argument"
+ripgrep-12.1.1/crates/core/args.rs:1438:21 clippy::doc_markdown "you should put `OsStr` between ticks in the documentation"
+ripgrep-12.1.1/crates/core/args.rs:1520:44 clippy::redundant_closure_for_method_calls "redundant closure found"
+ripgrep-12.1.1/crates/core/args.rs:1524:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+ripgrep-12.1.1/crates/core/args.rs:1635:14 clippy::doc_markdown "you should put `values_of_lossy` between ticks in the documentation"
+ripgrep-12.1.1/crates/core/args.rs:1693:41 clippy::redundant_closure_for_method_calls "redundant closure found"
+ripgrep-12.1.1/crates/core/args.rs:1770:17 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
+ripgrep-12.1.1/crates/core/args.rs:287:13 clippy::similar_names "binding's name is too similar to existing binding"
+ripgrep-12.1.1/crates/core/args.rs:33:1 clippy::single_component_path_imports "this import is redundant"
+ripgrep-12.1.1/crates/core/args.rs:34:1 clippy::single_component_path_imports "this import is redundant"
+ripgrep-12.1.1/crates/core/args.rs:35:1 clippy::single_component_path_imports "this import is redundant"
+ripgrep-12.1.1/crates/core/args.rs:369:5 clippy::upper_case_acronyms "name `JSON` contains a capitalized acronym"
+ripgrep-12.1.1/crates/core/args.rs:410:14 clippy::trivially_copy_pass_by_ref "this argument (2 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+ripgrep-12.1.1/crates/core/args.rs:475:18 clippy::match_same_arms "this `match` has identical arm bodies"
+ripgrep-12.1.1/crates/core/args.rs:512:19 clippy::doc_markdown "you should put `ArgMatches` between ticks in the documentation"
+ripgrep-12.1.1/crates/core/args.rs:549:16 clippy::wrong_self_convention "methods called `to_*` usually take self by reference; consider choosing a less ambiguous name"
+ripgrep-12.1.1/crates/core/args.rs:71:5 clippy::upper_case_acronyms "name `PCRE2Version` contains a capitalized acronym"
+ripgrep-12.1.1/crates/core/args.rs:76:18 clippy::trivially_copy_pass_by_ref "this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+ripgrep-12.1.1/crates/core/args.rs:77:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+ripgrep-12.1.1/crates/core/args.rs:923:42 clippy::doc_markdown "you should put `BinaryDetection::quit` between ticks in the documentation"
+ripgrep-12.1.1/crates/core/config.rs:13:1 clippy::single_component_path_imports "this import is redundant"
+ripgrep-12.1.1/crates/core/config.rs:58:6 clippy::type_complexity "very complex type used. Consider factoring parts into `type` definitions"
+ripgrep-12.1.1/crates/core/config.rs:79:6 clippy::type_complexity "very complex type used. Consider factoring parts into `type` definitions"
+ripgrep-12.1.1/crates/core/logger.rs:11:30 clippy::doc_markdown "you should put `max_level` between ticks in the documentation"
+ripgrep-12.1.1/crates/core/logger.rs:15:16 clippy::redundant_static_lifetimes "constants have by default a `'static` lifetime"
+ripgrep-12.1.1/crates/core/main.rs:55:19 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+ripgrep-12.1.1/crates/core/main.rs:56:9 clippy::enum_glob_use "usage of wildcard import for enum variants"
+ripgrep-12.1.1/crates/core/messages.rs:46:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+ripgrep-12.1.1/crates/core/messages.rs:51:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+ripgrep-12.1.1/crates/core/messages.rs:62:1 clippy::module_name_repetitions "item name ends with its containing module's name"
+ripgrep-12.1.1/crates/core/path_printer.rs:27:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+ripgrep-12.1.1/crates/core/path_printer.rs:89:9 clippy::if_not_else "unnecessary boolean `not` operation"
+ripgrep-12.1.1/crates/core/search.rs:185:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+ripgrep-12.1.1/crates/core/search.rs:224:5 clippy::upper_case_acronyms "name `JSON` contains a capitalized acronym"
+ripgrep-12.1.1/crates/core/search.rs:292:9 clippy::write_with_newline "using `write!()` with a format string that ends in a single newline"
+ripgrep-12.1.1/crates/core/search.rs:311:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+ripgrep-12.1.1/crates/core/search.rs:377:12 clippy::nonminimal_bool "this boolean expression can be simplified"
+ripgrep-12.1.1/crates/core/search.rs:423:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+ripgrep-12.1.1/crates/core/search.rs:447:13 clippy::enum_glob_use "usage of wildcard import for enum variants"
+ripgrep-12.1.1/crates/core/search.rs:472:24 clippy::map_clone "you are using an explicit closure for cloning elements"
+ripgrep-12.1.1/crates/core/search.rs:472:41 clippy::redundant_closure_for_method_calls "redundant closure found"
+ripgrep-12.1.1/crates/core/search.rs:480:24 clippy::map_clone "you are using an explicit closure for cloning elements"
+ripgrep-12.1.1/crates/core/search.rs:480:41 clippy::redundant_closure_for_method_calls "redundant closure found"
+ripgrep-12.1.1/crates/core/search.rs:49:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+ripgrep-12.1.1/crates/core/search.rs:509:24 clippy::map_clone "you are using an explicit closure for cloning elements"
+ripgrep-12.1.1/crates/core/search.rs:509:41 clippy::redundant_closure_for_method_calls "redundant closure found"
+ripgrep-12.1.1/crates/core/search.rs:517:24 clippy::map_clone "you are using an explicit closure for cloning elements"
+ripgrep-12.1.1/crates/core/search.rs:517:41 clippy::redundant_closure_for_method_calls "redundant closure found"
+ripgrep-12.1.1/crates/core/search.rs:533:36 clippy::cast_lossless "casting `u32` to `f64` may become silently lossy if you later change the type"
+ripgrep-12.1.1/crates/core/search.rs:533:5 clippy::cast_precision_loss "casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+ripgrep-12.1.1/crates/core/subject.rs:20:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+ripgrep-12.1.1/crates/core/subject.rs:4:1 clippy::single_component_path_imports "this import is redundant"
+syn-1.0.54/build.rs:1:null clippy::cargo_common_metadata "package `syn` is missing `package.keywords` metadata"
+syn-1.0.54/build.rs:1:null clippy::multiple_crate_versions "could not read cargo metadata: `cargo metadata` exited with an error:  Downloading crates ...\n  Downloaded syn-test-suite v0.0.0\nerror: failed to verify the checksum of `syn-test-suite v0.0.0`"
+syn-1.0.54/src/lib.rs:1:null clippy::cargo_common_metadata "package `syn` is missing `package.keywords` metadata"
+syn-1.0.54/src/lib.rs:1:null clippy::multiple_crate_versions "could not read cargo metadata: `cargo metadata` exited with an error:  Downloading crates ...\n  Downloaded syn-test-suite v0.0.0\nerror: failed to verify the checksum of `syn-test-suite v0.0.0`"
+syn-1.0.54/src/lit.rs:1397:40 clippy::redundant_else "redundant else block"
+syn-1.0.54/src/lit.rs:1405:28 clippy::redundant_else "redundant else block"
+syn-1.0.54/src/lit.rs:1485:32 clippy::redundant_else "redundant else block"
+unicode-xid-0.2.1/src/lib.rs:1:null clippy::cargo_common_metadata "package `unicode-xid` is missing `package.categories` metadata"
+unicode-xid-0.2.1/src/lib.rs:56:11 clippy::upper_case_acronyms "name `UnicodeXID` contains a capitalized acronym"
+unicode-xid-0.2.1/src/lib.rs:57:64 clippy::doc_markdown "you should put `XID_Start` between ticks in the documentation"
+unicode-xid-0.2.1/src/lib.rs:60:10 clippy::doc_markdown "you should put `XID_Start` between ticks in the documentation"
+unicode-xid-0.2.1/src/lib.rs:62:27 clippy::doc_markdown "you should put `ID_Start` between ticks in the documentation"
+unicode-xid-0.2.1/src/lib.rs:62:67 clippy::doc_markdown "you should put `NFKx` between ticks in the documentation"
+unicode-xid-0.2.1/src/lib.rs:63:21 clippy::wrong_self_convention "methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name"
+unicode-xid-0.2.1/src/lib.rs:65:61 clippy::doc_markdown "you should put `XID_Continue` between ticks in the documentation"
+unicode-xid-0.2.1/src/lib.rs:68:10 clippy::doc_markdown "you should put `XID_Continue` between ticks in the documentation"
+unicode-xid-0.2.1/src/lib.rs:70:28 clippy::doc_markdown "you should put `ID_Continue` between ticks in the documentation"
+unicode-xid-0.2.1/src/lib.rs:70:72 clippy::doc_markdown "you should put `NFKx` between ticks in the documentation"
+unicode-xid-0.2.1/src/lib.rs:71:24 clippy::wrong_self_convention "methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name"
+xsv-0.13.0/src/cmd/cat.rs:101:34 clippy::redundant_closure_for_method_calls "redundant closure found"
+xsv-0.13.0/src/cmd/cat.rs:42:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+xsv-0.13.0/src/cmd/cat.rs:53:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv-0.13.0/src/cmd/cat.rs:7:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv-0.13.0/src/cmd/count.rs:32:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv-0.13.0/src/cmd/count.rs:38:9 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+xsv-0.13.0/src/cmd/count.rs:42:33 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+xsv-0.13.0/src/cmd/count.rs:50:5 clippy::unit_arg "passing a unit value to a function"
+xsv-0.13.0/src/cmd/count.rs:7:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv-0.13.0/src/cmd/fixlengths.rs:45:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv-0.13.0/src/cmd/fixlengths.rs:50:18 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+xsv-0.13.0/src/cmd/fixlengths.rs:62:30 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+xsv-0.13.0/src/cmd/fixlengths.rs:9:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv-0.13.0/src/cmd/flatten.rs:10:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv-0.13.0/src/cmd/flatten.rs:51:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv-0.13.0/src/cmd/fmt.rs:50:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv-0.13.0/src/cmd/fmt.rs:55:13 clippy::similar_names "binding's name is too similar to existing binding"
+xsv-0.13.0/src/cmd/fmt.rs:7:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv-0.13.0/src/cmd/frequency.rs:148:43 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
+xsv-0.13.0/src/cmd/frequency.rs:149:43 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
+xsv-0.13.0/src/cmd/frequency.rs:15:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv-0.13.0/src/cmd/frequency.rs:169:13 clippy::similar_names "binding's name is too similar to existing binding"
+xsv-0.13.0/src/cmd/frequency.rs:176:17 clippy::if_not_else "unnecessary boolean `not` operation"
+xsv-0.13.0/src/cmd/frequency.rs:178:24 clippy::collapsible_else_if "this `else { if .. }` block can be collapsed"
+xsv-0.13.0/src/cmd/frequency.rs:77:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv-0.13.0/src/cmd/frequency.rs:93:31 clippy::explicit_into_iter_loop "it is more concise to loop over containers instead of using explicit iteration methods"
+xsv-0.13.0/src/cmd/headers.rs:43:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv-0.13.0/src/cmd/headers.rs:49:17 clippy::explicit_into_iter_loop "it is more concise to loop over containers instead of using explicit iteration methods"
+xsv-0.13.0/src/cmd/headers.rs:9:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv-0.13.0/src/cmd/index.rs:11:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv-0.13.0/src/cmd/index.rs:45:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv-0.13.0/src/cmd/input.rs:42:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv-0.13.0/src/cmd/input.rs:47:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv-0.13.0/src/cmd/input.rs:7:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv-0.13.0/src/cmd/join.rs:17:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv-0.13.0/src/cmd/join.rs:194:29 clippy::similar_names "binding's name is too similar to existing binding"
+xsv-0.13.0/src/cmd/join.rs:224:22 clippy::similar_names "binding's name is too similar to existing binding"
+xsv-0.13.0/src/cmd/join.rs:293:14 clippy::similar_names "binding's name is too similar to existing binding"
+xsv-0.13.0/src/cmd/join.rs:293:20 clippy::similar_names "binding's name is too similar to existing binding"
+xsv-0.13.0/src/cmd/join.rs:297:13 clippy::redundant_field_names "redundant field names in struct initialization"
+xsv-0.13.0/src/cmd/join.rs:298:13 clippy::redundant_field_names "redundant field names in struct initialization"
+xsv-0.13.0/src/cmd/join.rs:299:13 clippy::redundant_field_names "redundant field names in struct initialization"
+xsv-0.13.0/src/cmd/join.rs:300:13 clippy::redundant_field_names "redundant field names in struct initialization"
+xsv-0.13.0/src/cmd/join.rs:308:9 clippy::unused_self "unused `self` argument"
+xsv-0.13.0/src/cmd/join.rs:342:38 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+xsv-0.13.0/src/cmd/join.rs:342:46 clippy::unseparated_literal_suffix "integer type suffix should be separated by an underscore"
+xsv-0.13.0/src/cmd/join.rs:347:9 clippy::if_not_else "unnecessary boolean `not` operation"
+xsv-0.13.0/src/cmd/join.rs:372:44 clippy::redundant_closure_for_method_calls "redundant closure found"
+xsv-0.13.0/src/cmd/join.rs:375:33 clippy::similar_names "binding's name is too similar to existing binding"
+xsv-0.13.0/src/cmd/join.rs:392:13 clippy::redundant_field_names "redundant field names in struct initialization"
+xsv-0.13.0/src/cmd/join.rs:403:29 clippy::explicit_into_iter_loop "it is more concise to loop over containers instead of using explicit iteration methods"
+xsv-0.13.0/src/cmd/join.rs:426:13 clippy::if_not_else "unnecessary boolean `not` operation"
+xsv-0.13.0/src/cmd/join.rs:77:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+xsv-0.13.0/src/cmd/join.rs:94:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv-0.13.0/src/cmd/partition.rs:105:22 clippy::similar_names "binding's name is too similar to existing binding"
+xsv-0.13.0/src/cmd/partition.rs:106:22 clippy::redundant_slicing "redundant slicing of the whole range"
+xsv-0.13.0/src/cmd/partition.rs:139:13 clippy::redundant_field_names "redundant field names in struct initialization"
+xsv-0.13.0/src/cmd/partition.rs:15:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv-0.13.0/src/cmd/partition.rs:169:9 clippy::if_not_else "unnecessary boolean `not` operation"
+xsv-0.13.0/src/cmd/partition.rs:56:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv-0.13.0/src/cmd/partition.rs:77:9 clippy::unused_self "unused `self` argument"
+xsv-0.13.0/src/cmd/sample.rs:105:44 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
+xsv-0.13.0/src/cmd/sample.rs:115:21 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
+xsv-0.13.0/src/cmd/sample.rs:11:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv-0.13.0/src/cmd/sample.rs:51:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv-0.13.0/src/cmd/sample.rs:58:19 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+xsv-0.13.0/src/cmd/sample.rs:69:9 clippy::match_wildcard_for_single_variants "wildcard match will miss any future added variants"
+xsv-0.13.0/src/cmd/sample.rs:75:16 clippy::explicit_into_iter_loop "it is more concise to loop over containers instead of using explicit iteration methods"
+xsv-0.13.0/src/cmd/sample.rs:91:42 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
+xsv-0.13.0/src/cmd/sample.rs:92:43 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
+xsv-0.13.0/src/cmd/search.rs:51:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv-0.13.0/src/cmd/search.rs:9:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv-0.13.0/src/cmd/select.rs:60:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv-0.13.0/src/cmd/select.rs:8:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv-0.13.0/src/cmd/slice.rs:57:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv-0.13.0/src/cmd/slice.rs:9:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv-0.13.0/src/cmd/sort.rs:11:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv-0.13.0/src/cmd/sort.rs:138:47 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+xsv-0.13.0/src/cmd/sort.rs:139:51 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+xsv-0.13.0/src/cmd/sort.rs:48:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv-0.13.0/src/cmd/sort.rs:91:14 clippy::explicit_into_iter_loop "it is more concise to loop over containers instead of using explicit iteration methods"
+xsv-0.13.0/src/cmd/split.rs:14:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv-0.13.0/src/cmd/split.rs:61:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv-0.13.0/src/cmd/split.rs:94:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+xsv-0.13.0/src/cmd/split.rs:96:14 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+xsv-0.13.0/src/cmd/split.rs:99:13 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
+xsv-0.13.0/src/cmd/stats.rs:110:36 clippy::redundant_closure_for_method_calls "redundant closure found"
+xsv-0.13.0/src/cmd/stats.rs:127:14 clippy::needless_pass_by_value "this argument is passed by value, but not consumed in the function body"
+xsv-0.13.0/src/cmd/stats.rs:138:43 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
+xsv-0.13.0/src/cmd/stats.rs:139:43 clippy::cast_possible_truncation "casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers"
+xsv-0.13.0/src/cmd/stats.rs:162:25 clippy::explicit_into_iter_loop "it is more concise to loop over containers instead of using explicit iteration methods"
+xsv-0.13.0/src/cmd/stats.rs:22:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv-0.13.0/src/cmd/stats.rs:231:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+xsv-0.13.0/src/cmd/stats.rs:262:35 clippy::default_trait_access "calling `cmd::stats::TypedSum::default()` is more clear than this expression"
+xsv-0.13.0/src/cmd/stats.rs:263:40 clippy::default_trait_access "calling `cmd::stats::TypedMinMax::default()` is more clear than this expression"
+xsv-0.13.0/src/cmd/stats.rs:264:39 clippy::default_trait_access "calling `stats::OnlineStats::default()` is more clear than this expression"
+xsv-0.13.0/src/cmd/stats.rs:265:58 clippy::default_trait_access "calling `stats::Unsorted::default()` is more clear than this expression"
+xsv-0.13.0/src/cmd/stats.rs:266:41 clippy::default_trait_access "calling `stats::Unsorted::default()` is more clear than this expression"
+xsv-0.13.0/src/cmd/stats.rs:268:18 clippy::default_trait_access "calling `cmd::stats::FieldType::default()` is more clear than this expression"
+xsv-0.13.0/src/cmd/stats.rs:269:13 clippy::redundant_field_names "redundant field names in struct initialization"
+xsv-0.13.0/src/cmd/stats.rs:270:13 clippy::redundant_field_names "redundant field names in struct initialization"
+xsv-0.13.0/src/cmd/stats.rs:271:13 clippy::redundant_field_names "redundant field names in struct initialization"
+xsv-0.13.0/src/cmd/stats.rs:272:13 clippy::redundant_field_names "redundant field names in struct initialization"
+xsv-0.13.0/src/cmd/stats.rs:273:13 clippy::redundant_field_names "redundant field names in struct initialization"
+xsv-0.13.0/src/cmd/stats.rs:274:13 clippy::redundant_field_names "redundant field names in struct initialization"
+xsv-0.13.0/src/cmd/stats.rs:283:9 clippy::option_map_unit_fn "called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`"
+xsv-0.13.0/src/cmd/stats.rs:284:9 clippy::option_map_unit_fn "called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`"
+xsv-0.13.0/src/cmd/stats.rs:285:9 clippy::option_map_unit_fn "called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`"
+xsv-0.13.0/src/cmd/stats.rs:290:21 clippy::option_map_unit_fn "called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`"
+xsv-0.13.0/src/cmd/stats.rs:293:25 clippy::match_same_arms "this `match` has identical arm bodies"
+xsv-0.13.0/src/cmd/stats.rs:297:25 clippy::option_map_unit_fn "called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`"
+xsv-0.13.0/src/cmd/stats.rs:301:21 clippy::option_map_unit_fn "called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`"
+xsv-0.13.0/src/cmd/stats.rs:302:21 clippy::option_map_unit_fn "called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`"
+xsv-0.13.0/src/cmd/stats.rs:308:18 clippy::wrong_self_convention "methods called `to_*` usually take self by reference; consider choosing a less ambiguous name"
+xsv-0.13.0/src/cmd/stats.rs:318:9 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+xsv-0.13.0/src/cmd/stats.rs:322:45 clippy::redundant_closure_for_method_calls "redundant closure found"
+xsv-0.13.0/src/cmd/stats.rs:322:9 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+xsv-0.13.0/src/cmd/stats.rs:327:9 clippy::if_not_else "unnecessary boolean `not` operation"
+xsv-0.13.0/src/cmd/stats.rs:330:13 clippy::single_match_else "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`"
+xsv-0.13.0/src/cmd/stats.rs:338:45 clippy::redundant_closure_for_method_calls "redundant closure found"
+xsv-0.13.0/src/cmd/stats.rs:402:16 clippy::redundant_pattern_matching "redundant pattern matching, consider using `is_ok()`"
+xsv-0.13.0/src/cmd/stats.rs:403:16 clippy::redundant_pattern_matching "redundant pattern matching, consider using `is_ok()`"
+xsv-0.13.0/src/cmd/stats.rs:407:18 clippy::trivially_copy_pass_by_ref "this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+xsv-0.13.0/src/cmd/stats.rs:411:16 clippy::trivially_copy_pass_by_ref "this argument (1 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+xsv-0.13.0/src/cmd/stats.rs:427:56 clippy::match_same_arms "this `match` has identical arm bodies"
+xsv-0.13.0/src/cmd/stats.rs:429:56 clippy::match_same_arms "this `match` has identical arm bodies"
+xsv-0.13.0/src/cmd/stats.rs:430:60 clippy::match_same_arms "this `match` has identical arm bodies"
+xsv-0.13.0/src/cmd/stats.rs:430:60 clippy::match_same_arms "this `match` has identical arm bodies"
+xsv-0.13.0/src/cmd/stats.rs:454:5 clippy::doc_markdown "you should put `TypedSum` between ticks in the documentation"
+xsv-0.13.0/src/cmd/stats.rs:473:43 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+xsv-0.13.0/src/cmd/stats.rs:504:56 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+xsv-0.13.0/src/cmd/stats.rs:505:51 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+xsv-0.13.0/src/cmd/stats.rs:511:5 clippy::doc_markdown "you should put `TypedMinMax` between ticks in the documentation"
+xsv-0.13.0/src/cmd/stats.rs:536:35 clippy::cast_possible_truncation "casting `f64` to `i64` may truncate the value"
+xsv-0.13.0/src/cmd/stats.rs:544:33 clippy::cast_precision_loss "casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)"
+xsv-0.13.0/src/cmd/stats.rs:592:22 clippy::default_trait_access "calling `stats::MinMax::default()` is more clear than this expression"
+xsv-0.13.0/src/cmd/stats.rs:593:22 clippy::default_trait_access "calling `stats::MinMax::default()` is more clear than this expression"
+xsv-0.13.0/src/cmd/stats.rs:594:23 clippy::default_trait_access "calling `stats::MinMax::default()` is more clear than this expression"
+xsv-0.13.0/src/cmd/stats.rs:595:21 clippy::default_trait_access "calling `stats::MinMax::default()` is more clear than this expression"
+xsv-0.13.0/src/cmd/stats.rs:71:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+xsv-0.13.0/src/cmd/stats.rs:86:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv-0.13.0/src/cmd/table.rs:10:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv-0.13.0/src/cmd/table.rs:50:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv-0.13.0/src/cmd/table.rs:54:9 clippy::similar_names "binding's name is too similar to existing binding"
+xsv-0.13.0/src/config.rs:113:43 clippy::or_fun_call "use of `unwrap_or` followed by a function call"
+xsv-0.13.0/src/config.rs:58:1 clippy::struct_excessive_bools "more than 3 bools in a struct"
+xsv-0.13.0/src/config.rs:77:28 clippy::explicit_deref_methods "explicit deref method call"
+xsv-0.13.0/src/config.rs:90:13 clippy::redundant_field_names "redundant field names in struct initialization"
+xsv-0.13.0/src/index.rs:31:13 clippy::redundant_field_names "redundant field names in struct initialization"
+xsv-0.13.0/src/main.rs:164:49 clippy::redundant_clone "redundant clone"
+xsv-0.13.0/src/main.rs:1:null clippy::cargo_common_metadata "package `xsv` is missing `package.categories` metadata"
+xsv-0.13.0/src/main.rs:1:null clippy::multiple_crate_versions "multiple versions for dependency `rand_core`: 0.3.1, 0.4.2"
+xsv-0.13.0/src/main.rs:1:null clippy::multiple_crate_versions "multiple versions for dependency `rand`: 0.3.23, 0.4.6"
+xsv-0.13.0/src/main.rs:75:16 clippy::redundant_static_lifetimes "statics have by default a `'static` lifetime"
+xsv-0.13.0/src/select.rs:13:1 clippy::module_name_repetitions "item name starts with its containing module's name"
+xsv-0.13.0/src/select.rs:154:5 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Result`"
+xsv-0.13.0/src/select.rs:250:33 clippy::similar_names "binding's name is too similar to existing binding"
+xsv-0.13.0/src/select.rs:250:43 clippy::similar_names "binding's name is too similar to existing binding"
+xsv-0.13.0/src/select.rs:255:39 clippy::range_plus_one "an inclusive range would be more readable"
+xsv-0.13.0/src/select.rs:280:20 clippy::len_zero "length comparison to zero"
+xsv-0.13.0/src/select.rs:29:13 clippy::redundant_field_names "redundant field names in struct initialization"
+xsv-0.13.0/src/select.rs:360:62 clippy::trivially_copy_pass_by_ref "this argument (8 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)"
+xsv-0.13.0/src/select.rs:360:9 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Option`"
+xsv-0.13.0/src/select.rs:375:9 clippy::stable_sort_primitive "used `sort` on primitive type `usize`"
+xsv-0.13.0/src/select.rs:379:18 clippy::explicit_into_iter_loop "it is more concise to loop over containers instead of using explicit iteration methods"
+xsv-0.13.0/src/select.rs:416:5 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
+xsv-0.13.0/src/select.rs:419:9 clippy::unnecessary_wraps "this function's return value is unnecessarily wrapped by `Option`"
+xsv-0.13.0/src/select.rs:420:27 clippy::option_option "consider using `Option<T>` instead of `Option<Option<T>>` or a custom enum if you need to distinguish all 3 cases"
+xsv-0.13.0/src/select.rs:99:17 clippy::similar_names "binding's name is too similar to existing binding"
+xsv-0.13.0/src/util.rs:150:5 clippy::doc_markdown "you should put bare URLs between `<`/`>` or make a proper Markdown link"
+xsv-0.13.0/src/util.rs:37:33 clippy::map_clone "you are using an explicit closure for copying elements"
+xsv-0.13.0/src/util.rs:90:1 clippy::needless_lifetimes "explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)"
 
 
 

From 0373dc3ade666c4fb06ab9cca5fa840d4988a9c3 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Fri, 22 Jan 2021 19:04:28 +0100
Subject: [PATCH 102/108] Added documentation for adding a configuration to
 lints

* Fixed some spelling
---
 doc/adding_lints.md | 76 +++++++++++++++++++++++++++++++++++++++++++++
 doc/basics.md       |  5 +--
 2 files changed, 79 insertions(+), 2 deletions(-)

diff --git a/doc/adding_lints.md b/doc/adding_lints.md
index 1a7a30c61be5b..fd2a7d171d020 100644
--- a/doc/adding_lints.md
+++ b/doc/adding_lints.md
@@ -23,6 +23,7 @@ because that's clearly a non-descriptive name.
   - [Running rustfmt](#running-rustfmt)
   - [Debugging](#debugging)
   - [PR Checklist](#pr-checklist)
+  - [Adding configuration to a lint](#adding-configuration-to-a-lint)
   - [Cheatsheet](#cheatsheet)
 
 ## Setup
@@ -526,6 +527,81 @@ Before submitting your PR make sure you followed all of the basic requirements:
 - \[ ] Added lint documentation
 - \[ ] Run `cargo dev fmt`
 
+## Adding configuration to a lint
+
+Clippy supports the configuration of lints values using a `clippy.toml` file in the workspace 
+directory. Adding a configuration to a lint can be useful for thresholds or to constrain some
+behavior that can be seen as a false positive for some users. Adding a configuration is done 
+in the following steps:
+
+1. Adding a new configuration entry to [clippy_lints::utils::conf](/clippy_lints/src/utils/conf.rs)
+    like this:
+    ```rust
+    /// Lint: LINT_NAME. <The configuration field doc comment>
+    (configuration_ident, "configuration_value": Type, DefaultValue),
+    ```
+    The configuration value and identifier should usually be the same. The doc comment will be 
+    automatically added to the lint documentation.
+2. Adding the configuration value to the lint impl struct:
+    1. This first requires the definition of a lint impl struct. Lint impl structs are usually 
+        generated with the `declare_lint_pass!` macro. This struct needs to be defined manually
+        to add some kind of metadata to it:
+        ```rust
+        // Generated struct definition
+        declare_lint_pass!(StructName => [
+            LINT_NAME
+        ]);
+
+        // New manual definition struct
+        #[derive(Copy, Clone)]
+        pub struct StructName {}
+
+        impl_lint_pass!(StructName => [
+            LINT_NAME
+        ]);
+        ```
+    
+    2. Next add the configuration value and a corresponding creation method like this:
+        ```rust
+        #[derive(Copy, Clone)]
+        pub struct StructName {
+            configuration_ident: Type,
+        }
+
+        // ...
+
+        impl StructName {
+            pub fn new(configuration_ident: Type) -> Self {
+                Self {
+                    configuration_ident,
+                }
+            }
+        }
+        ```
+3. Passing the configuration value to the lint impl struct:
+
+    First find the struct construction in the [clippy_lints lib file](/clippy_lints/src/lib.rs). 
+    Make sure that `clippy dev update_lints` added it beforehand. The configuration value is now 
+    cloned or copied into a local value that is then passed to the impl struct like this:
+    ```rust
+    // Default generated registration:
+    store.register_late_pass(|| box module::StructName);
+
+    // New registration with configuration value
+    let configuration_ident = conf.configuration_ident.clone();
+    store.register_late_pass(move || box module::StructName::new(configuration_ident));
+    ```
+
+    Congratulations the work is almost done. The configuration value can now be accessed
+    in the linting code via `self.configuration_ident`.
+
+4. Adding tests:
+    1. The default configured value can be tested like any normal lint in [`tests/ui`](/tests/ui).
+    2. The configuration itself will be tested separately in [`tests/ui-toml`](/tests/ui-toml). 
+        Simply add a new subfolder with a fitting name. This folder contains a `clippy.toml` file 
+        with the configuration value and a rust file that should be linted by clippy. The test can 
+        otherwise be written as usual.
+
 ## Cheatsheet
 
 Here are some pointers to things you are likely going to need for every lint:
diff --git a/doc/basics.md b/doc/basics.md
index 8f2a20bfe2468..57f83bdf32bc2 100644
--- a/doc/basics.md
+++ b/doc/basics.md
@@ -11,6 +11,7 @@ the codebase take a look at [Adding Lints] or [Common Tools].
   - [Get the Code](#get-the-code)
   - [Building and Testing](#building-and-testing)
   - [`cargo dev`](#cargo-dev)
+  - [Common Abbreviations](#common-abbreviations)
   - [PR](#pr)
 
 ## Get the Code
@@ -109,7 +110,7 @@ See <https://rustc-dev-guide.rust-lang.org/contributing.html#opening-a-pr>.
 | TCX          | Type context                           |
 
 This is a concise list of abbreviations that can come up during clippy development. An extensive
-genal list can be found in the [rustc-dev-guide glossary][glossary]. Always feel free to ask if
+general list can be found in the [rustc-dev-guide glossary][glossary]. Always feel free to ask if
 an abbreviation or meaning is unclear to you.
 
-[glossary]: https://rustc-dev-guide.rust-lang.org/appendix/glossary.html
\ No newline at end of file
+[glossary]: https://rustc-dev-guide.rust-lang.org/appendix/glossary.html

From e0ae980fab38e61bf39380e69bbf0000e681a9f8 Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Mon, 25 Jan 2021 14:35:57 -0800
Subject: [PATCH 103/108] Better suggestion span

---
 clippy_lints/src/exhaustive_items.rs | 43 +++++++++++-----------------
 1 file changed, 16 insertions(+), 27 deletions(-)

diff --git a/clippy_lints/src/exhaustive_items.rs b/clippy_lints/src/exhaustive_items.rs
index 4749e36238cb5..32b1299efce91 100644
--- a/clippy_lints/src/exhaustive_items.rs
+++ b/clippy_lints/src/exhaustive_items.rs
@@ -1,4 +1,4 @@
-use crate::utils::{indent_of, snippet_opt, span_lint_and_help, span_lint_and_then};
+use crate::utils::{indent_of, span_lint_and_then};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Item, ItemKind};
@@ -80,33 +80,22 @@ impl LateLintPass<'_> for ExhaustiveItems {
                 } else {
                     (EXHAUSTIVE_STRUCTS, "exported structs should not be exhaustive")
                 };
-                let suggestion_span = item.span.until(item.ident.span);
+                let suggestion_span = item.span.shrink_to_lo();
+                let indent = " ".repeat(indent_of(cx, item.span).unwrap_or(0));
+                span_lint_and_then(
+                    cx,
+                    lint,
+                    item.span,
+                    msg,
+                    |diag| {
+                        let sugg = format!("#[non_exhaustive]\n{}", indent);
+                        diag.span_suggestion(suggestion_span,
+                                             "try adding #[non_exhaustive]",
+                                             sugg,
+                                             Applicability::MaybeIncorrect);
+                    }
+                );
 
-                if let Some(snippet) = snippet_opt(cx, suggestion_span) {
-                    let indent = " ".repeat(indent_of(cx, item.span).unwrap_or(0));
-                    span_lint_and_then(
-                        cx,
-                        lint,
-                        item.span,
-                        msg,
-                        |diag| {
-                            let sugg = format!("#[non_exhaustive]\n{}{}", indent, snippet);
-                            diag.span_suggestion(suggestion_span,
-                                                 "try adding #[non_exhaustive]",
-                                                 sugg,
-                                                 Applicability::MaybeIncorrect);
-                        }
-                    );
-                } else {
-                    span_lint_and_help(
-                        cx,
-                        lint,
-                        item.span,
-                        msg,
-                        None,
-                        "try adding #[non_exhaustive]",
-                    );
-                }
             }
         }
     }

From 3e3dff71357005556aba8d9a7893829f7510b079 Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Mon, 25 Jan 2021 14:39:03 -0800
Subject: [PATCH 104/108] Add test with attrs

---
 tests/ui/exhaustive_items.fixed  | 10 ++++++++++
 tests/ui/exhaustive_items.rs     |  9 +++++++++
 tests/ui/exhaustive_items.stderr | 21 +++++++++++++++++++--
 3 files changed, 38 insertions(+), 2 deletions(-)

diff --git a/tests/ui/exhaustive_items.fixed b/tests/ui/exhaustive_items.fixed
index 7e355d2a58b33..8174a0175ab32 100644
--- a/tests/ui/exhaustive_items.fixed
+++ b/tests/ui/exhaustive_items.fixed
@@ -16,6 +16,16 @@ pub mod enums {
         Quux(String),
     }
 
+    /// Some docs
+    #[repr(C)]
+    #[non_exhaustive]
+    pub enum ExhaustiveWithAttrs {
+        Foo,
+        Bar,
+        Baz,
+        Quux(String),
+    }
+
     // no warning, already non_exhaustive
     #[non_exhaustive]
     pub enum NonExhaustive {
diff --git a/tests/ui/exhaustive_items.rs b/tests/ui/exhaustive_items.rs
index ed86b50be30a1..b476f09f8a087 100644
--- a/tests/ui/exhaustive_items.rs
+++ b/tests/ui/exhaustive_items.rs
@@ -15,6 +15,15 @@ pub mod enums {
         Quux(String),
     }
 
+    /// Some docs
+    #[repr(C)]
+    pub enum ExhaustiveWithAttrs {
+        Foo,
+        Bar,
+        Baz,
+        Quux(String),
+    }
+
     // no warning, already non_exhaustive
     #[non_exhaustive]
     pub enum NonExhaustive {
diff --git a/tests/ui/exhaustive_items.stderr b/tests/ui/exhaustive_items.stderr
index a24e64b67058a..7369fe75a4f74 100644
--- a/tests/ui/exhaustive_items.stderr
+++ b/tests/ui/exhaustive_items.stderr
@@ -20,8 +20,25 @@ LL |     #[non_exhaustive]
 LL |     pub enum Exhaustive {
    |
 
+error: exported enums should not be exhaustive
+  --> $DIR/exhaustive_items.rs:20:5
+   |
+LL | /     pub enum ExhaustiveWithAttrs {
+LL | |         Foo,
+LL | |         Bar,
+LL | |         Baz,
+LL | |         Quux(String),
+LL | |     }
+   | |_____^
+   |
+help: try adding #[non_exhaustive]
+   |
+LL |     #[non_exhaustive]
+LL |     pub enum ExhaustiveWithAttrs {
+   |
+
 error: exported structs should not be exhaustive
-  --> $DIR/exhaustive_items.rs:46:5
+  --> $DIR/exhaustive_items.rs:55:5
    |
 LL | /     pub struct Exhaustive {
 LL | |         foo: u8,
@@ -40,5 +57,5 @@ LL |     #[non_exhaustive]
 LL |     pub struct Exhaustive {
    |
 
-error: aborting due to 2 previous errors
+error: aborting due to 3 previous errors
 

From cbf9d492b9a60c7267907731941d14ec96510681 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Tue, 26 Jan 2021 17:38:37 -0600
Subject: [PATCH 105/108] Fix some website syntax highlighting

---
 util/export.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/util/export.py b/util/export.py
index 5d1bd60acf3d6..1248e6b6a26a7 100755
--- a/util/export.py
+++ b/util/export.py
@@ -22,7 +22,10 @@ def parse_code_block(match):
     lines = []
 
     for line in match.group(0).split('\n'):
-        if not line.startswith('# '):
+        # fix syntax highlighting for headers like ```rust,ignore
+        if line.startswith('```rust'):
+            lines.append('```rust')
+        elif not line.startswith('# '):
             lines.append(line)
 
     return '\n'.join(lines)

From 60ab57e4eb0bc8845e0a5a683e10d2e39147094a Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Sat, 30 Jan 2021 15:52:02 +0100
Subject: [PATCH 106/108] Bump nightly version -> 2021-01-30

---
 rust-toolchain | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rust-toolchain b/rust-toolchain
index 72935072f8cdd..f55d55d706587 100644
--- a/rust-toolchain
+++ b/rust-toolchain
@@ -1,3 +1,3 @@
 [toolchain]
-channel = "nightly-2021-01-15"
+channel = "nightly-2021-01-30"
 components = ["llvm-tools-preview", "rustc-dev", "rust-src", "rustfmt"]

From 797cf6554dd48792ed22c4f81322979548d542d1 Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Sat, 30 Jan 2021 17:43:00 +0100
Subject: [PATCH 107/108] Get rid of regex and lazy_static dependencies

---
 clippy_lints/Cargo.toml                                |  2 --
 .../src/case_sensitive_file_extension_comparisons.rs   | 10 ++++------
 2 files changed, 4 insertions(+), 8 deletions(-)

diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
index 38098f8a14c78..a9516560a6195 100644
--- a/clippy_lints/Cargo.toml
+++ b/clippy_lints/Cargo.toml
@@ -34,8 +34,6 @@ rustc-semver="1.1.0"
 url = { version =  "2.1.0", features = ["serde"] }
 quote = "1"
 syn = { version = "1", features = ["full"] }
-regex = "1.4"
-lazy_static = "1.4"
 
 [features]
 deny-warnings = []
diff --git a/clippy_lints/src/case_sensitive_file_extension_comparisons.rs b/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
index d5347ce6ed756..6969ac949d845 100644
--- a/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
+++ b/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
@@ -1,8 +1,6 @@
 use crate::utils::paths::STRING;
 use crate::utils::{match_def_path, span_lint_and_help};
 use if_chain::if_chain;
-use lazy_static::lazy_static;
-use regex::Regex;
 use rustc_ast::ast::LitKind;
 use rustc_hir::{Expr, ExprKind, PathSegment};
 use rustc_lint::{LateContext, LateLintPass};
@@ -41,14 +39,14 @@ declare_clippy_lint! {
 declare_lint_pass!(CaseSensitiveFileExtensionComparisons => [CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS]);
 
 fn check_case_sensitive_file_extension_comparison(ctx: &LateContext<'_>, expr: &Expr<'_>) -> Option<Span> {
-    lazy_static! {
-        static ref RE: Regex = Regex::new(r"^\.([a-z0-9]{1,5}|[A-Z0-9]{1,5})$").unwrap();
-    }
     if_chain! {
         if let ExprKind::MethodCall(PathSegment { ident, .. }, _, [obj, extension, ..], span) = expr.kind;
         if ident.as_str() == "ends_with";
         if let ExprKind::Lit(Spanned { node: LitKind::Str(ext_literal, ..), ..}) = extension.kind;
-        if RE.is_match(&ext_literal.as_str());
+        if (2..=6).contains(&ext_literal.as_str().len());
+        if ext_literal.as_str().starts_with('.');
+        if ext_literal.as_str().chars().skip(1).all(|c| c.is_uppercase() || c.is_digit(10))
+            || ext_literal.as_str().chars().skip(1).all(|c| c.is_lowercase() || c.is_digit(10));
         then {
             let mut ty = ctx.typeck_results().expr_ty(obj);
             ty = match ty.kind() {

From 3874631600811d964f18784859b34302d5533358 Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Sat, 30 Jan 2021 17:43:20 +0100
Subject: [PATCH 108/108] Remove unknown_clippy_lints allow attribute

---
 clippy_lints/src/utils/diagnostics.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/clippy_lints/src/utils/diagnostics.rs b/clippy_lints/src/utils/diagnostics.rs
index a7a6b5855b754..6caa04f651fae 100644
--- a/clippy_lints/src/utils/diagnostics.rs
+++ b/clippy_lints/src/utils/diagnostics.rs
@@ -186,8 +186,6 @@ pub fn span_lint_hir_and_then(
 ///     |
 ///     = note: `-D fold-any` implied by `-D warnings`
 /// ```
-
-#[allow(clippy::unknown_clippy_lints)]
 #[cfg_attr(feature = "internal-lints", allow(clippy::collapsible_span_lint_calls))]
 pub fn span_lint_and_sugg<'a, T: LintContext>(
     cx: &'a T,