From bd235707acd095fdd2b079d2992923d0d732a474 Mon Sep 17 00:00:00 2001 From: "kai.giebeler" Date: Fri, 27 Nov 2020 01:42:37 +0100 Subject: 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 fc6304118d9..95f5d33fb23 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", -- cgit 1.4.1-3-g733a5 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: 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 ff414f748ef..78d23e1e0ef 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 { -- cgit 1.4.1-3-g733a5 From 39f39d5405b7e55eb08cb927e78686a5ce7377d4 Mon Sep 17 00:00:00 2001 From: Matthias Krüger Date: Fri, 1 Jan 2021 17:43:24 +0100 Subject: 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 04b35835c6b..6372cb86616 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 84981a52597..319299862a7 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) {} + 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) {} + 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 94c7c3cadac..2ef6cf42387 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) {} + 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) {} + 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 c52e41c7889..f27b4e9cb20 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 -- cgit 1.4.1-3-g733a5 From 61f3d9d46b5cbfdb56069a95e5839abe8fda9acf Mon Sep 17 00:00:00 2001 From: Javier Alvarez Date: Wed, 23 Dec 2020 12:37:37 +0100 Subject: 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 + .../case_sensitive_file_extension_comparisons.rs | 88 ++++++++++++++++++++++ clippy_lints/src/lib.rs | 4 + .../case_sensitive_file_extension_comparisons.rs | 44 +++++++++++ ...ase_sensitive_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 64864c2e278..b0e9ad55b4f 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 a9516560a61..38098f8a14c 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 00000000000..b227e9a981a --- /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 { + 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 37a56bc20c8..ec433acf038 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(©_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 00000000000..68719c2bc6d --- /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 00000000000..05b98169f2d --- /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 + -- cgit 1.4.1-3-g733a5 From 1527fb61b9352c15d87ebcbc6f786baa2d390bcd Mon Sep 17 00:00:00 2001 From: Javier Alvarez Date: Wed, 23 Dec 2020 16:31:04 +0100 Subject: 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 ec3af94b9ca..2b4ecc73150 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); } -- cgit 1.4.1-3-g733a5 From e56973a8545d384d6dcb5271b54c90c584a58065 Mon Sep 17 00:00:00 2001 From: Javier Alvarez Date: Wed, 23 Dec 2020 16:59:17 +0100 Subject: 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 b227e9a981a..d5347ce6ed7 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]); -- cgit 1.4.1-3-g733a5 From 15d5ac6b2fb411370a4d116a2b3a11dc1b54fb42 Mon Sep 17 00:00:00 2001 From: Stanislav Tkach Date: Wed, 6 Jan 2021 13:26:35 +0200 Subject: 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 b97d97ea1a5..8c77e155b70 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 = None; /// foo.map_or(Err("error"), |v| Ok(v)); - /// - /// let foo: Option = None; - /// foo.map_or(Err("error"), |v| Ok(v)); /// ``` /// /// Use instead: -- cgit 1.4.1-3-g733a5 From 8490862cc37d7518c79d09d7911d86bfca2cea89 Mon Sep 17 00:00:00 2001 From: Cameron Steffen Date: Wed, 6 Jan 2021 15:14:01 -0600 Subject: 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 8f54cad7728..b2c9d4f8739 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 { - 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 { + fn item_child_by_name<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, name: &str) -> Option<&'tcx Export> { + 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 01e28ae5e9d..a3b19c2e394 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() {} -- cgit 1.4.1-3-g733a5 From 8d7417d8079b7f942e3a116ede6d36dc7a219e71 Mon Sep 17 00:00:00 2001 From: Jason Newcomb Date: Sun, 10 Jan 2021 23:32:23 -0500 Subject: 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 04b35835c6b..2239b519632 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 1c55af5dfb6..02266308fba 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 f69554d75f9..5eca07ab109 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 -- cgit 1.4.1-3-g733a5 From f2d493504cb863a30f45e8a0d5717285823f931e Mon Sep 17 00:00:00 2001 From: Cameron Steffen Date: Sat, 28 Nov 2020 16:56:59 -0600 Subject: 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 446426b3e61..855529378e6 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 6796b15289e..5981980988b 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: (); +} -- cgit 1.4.1-3-g733a5 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: 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 1d5fa8d06a9..5e9ffab7dfb 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 00000000000..ac6c3e4aba0 --- /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 = HashMap<(), ::Assoc>; +type TypeAlias2 = BTreeMap<(), ::Assoc>; + +fn main() {} -- cgit 1.4.1-3-g733a5 From 02f99bea87d0a3fe665aa825bccdcce7a8d190e9 Mon Sep 17 00:00:00 2001 From: Daniel Smith Date: Wed, 13 Jan 2021 16:08:15 -0500 Subject: 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 f136aa4572a..ae64c688744 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:** /// -- cgit 1.4.1-3-g733a5 From 85edd65bf69266dd7cec2ca6d7bb6941b6f85444 Mon Sep 17 00:00:00 2001 From: Jason Newcomb Date: Thu, 14 Jan 2021 14:26:26 -0500 Subject: 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 2239b519632..6ecd738d2f0 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 8f54cad7728..8f8c681ecb7 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 02266308fba..ca884b41c45 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 5eca07ab109..7ea6955b740 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 3a07c2ec542..20be4fa226c 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) { -- cgit 1.4.1-3-g733a5 From d72cb252f2f052a6b5794b56a0157cbd34751055 Mon Sep 17 00:00:00 2001 From: Takayuki Nakata Date: Fri, 15 Jan 2021 09:11:31 +0900 Subject: 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 4cfeaa153a0..ed580e56055 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 -- cgit 1.4.1-3-g733a5 From 36ff2f739c62f81d5ecc1850d9f3354d15de928d Mon Sep 17 00:00:00 2001 From: Jason Newcomb Date: Thu, 14 Jan 2021 22:02:04 -0500 Subject: 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 6ecd738d2f0..02021b87369 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 8f8c681ecb7..f81bf088ec4 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), -- cgit 1.4.1-3-g733a5 From 488153ff2ff678051f06a94dc4486632d788c328 Mon Sep 17 00:00:00 2001 From: flip1995 Date: Fri, 15 Jan 2021 10:56:44 +0100 Subject: 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 + clippy_lints/src/utils/sym.rs | 6 - clippy_lints/src/utils/sym_helper.rs | 7 + 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 +- tests/ui-internal/interning_defined_symbol.fixed | 9 +- tests/ui-internal/interning_defined_symbol.rs | 3 + tests/ui-internal/interning_defined_symbol.stderr | 14 +- tests/ui-internal/unnecessary_symbol_str.fixed | 16 ++ tests/ui-internal/unnecessary_symbol_str.rs | 16 ++ tests/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 ++-- 104 files changed, 2334 insertions(+), 254 deletions(-) create mode 100644 clippy_lints/src/needless_question_mark.rs delete mode 100644 clippy_lints/src/utils/sym.rs create mode 100644 clippy_lints/src/utils/sym_helper.rs 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 de8da99cdee..64864c2e278 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 645098e4cfc..b877806946c 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 = SyncLazy::new(|| match env::var None => env::current_dir().unwrap().join("target"), }); -pub fn bless() { - let test_dirs = [ +static CLIPPY_BUILD_TIME: SyncLazy> = 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 { + 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 4fdae38e3ab..2ea56c42faf 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 3edbe723922..9a00fc535fc 100644 --- a/clippy_lints/src/attrs.rs +++ b/clippy_lints/src/attrs.rs @@ -399,7 +399,7 @@ fn extract_clippy_lint(lint: &NestedMetaItem) -> Option { 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 42bff564de0..93ccc76d0c9 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 ae1143b2c50..90d31dece13 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 6f48ffeb0e9..944aaafb46d 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 a7aa2cb35c1..48899b33899 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 b0d7c7b3baa..f7224811e6e 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::>() diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs index b55f59f021d..b1e363663bb 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 a249117d182..853b3afdc3a 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 55087697812..40e93da8dff 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>, 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`), 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 53df3abbf54..1a722d39f73 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 1e7e5f53cc2..b010abda24d 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 2e55094d90c..58511c6d57c 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 e287aecb044..ea26c84cde1 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 5474b30bdec..e95caf6a35f 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 35b057d7b6a..f12994c7a60 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 281964ee5e8..1c5ab2874b0 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 29439e52c48..89f5b2ff311 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 220240acb7a..1818836d5d5 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 6b782385a38..9f9c108a85a 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 6e8102790a5..79aec928d29 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 004dd50a31b..8d0c3b8e0fe 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 27f1074a0dd..0e49eaab436 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 6b9a37b5252..d795f126457 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 bff53eb8cca..f1c06692e30 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 a435f86bfd8..c8f89f8046c 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 00000000000..9e9b79ee1cf --- /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, + /// } + /// + /// fn f(to: TO) -> Option { + /// Some(to.magic?) + /// } + /// + /// struct TR { + /// magic: Result, + /// } + /// + /// fn g(tr: Result) -> Result { + /// tr.and_then(|t| Ok(t.magic?)) + /// } + /// + /// ``` + /// Use instead: + /// ```rust + /// struct TO { + /// magic: Option, + /// } + /// + /// fn f(to: TO) -> Option { + /// to.magic + /// } + /// + /// struct TR { + /// magic: Result, + /// } + /// + /// fn g(tr: Result) -> Result { + /// 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`." +} + +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, +} + +impl NeedlessQuestionMark { + #[must_use] + pub fn new(msrv: Option) -> 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 and Option, + * 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> { + 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 391f893ef35..7bdf975ffd4 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 04b6e5d5847..ed314937ce8 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 7814065e31a..d96a9b025f0 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 b832add009f..c6329a1381c 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 803ebada54b..8cd6692ce03 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 35827e027aa..63548d8fdb4 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, 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 ca4fd9f3559..44e739725c8 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 f2f3dfa09a7..24da056770c 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 386987eb181..699fd51ccc1 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 675eaf4277a..c53727ba160 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 2696c5e781a..3b5a83d2a0b 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> makes sense if T is a large type (see #3530, + /// **Known problems:** Vec> 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::(); + /// (&mut 1u8 as *mut u8).cast::(); /// ``` 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::(); + /// let _ = mut_ptr.cast::(); + /// ``` + 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, +} + +impl PtrAsPtr { + #[must_use] + pub fn new(msrv: Option) -> 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 0bccfc15678..9b45d38afd4 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 { 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 07cd752184b..8ac5dd696b7 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 a6171794311..5349c4f7eb8 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 6a87f534369..b82909eaea6 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 b82ea66190f..72d1ca73929 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 efa9c3fab4a..c5334853986 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 24052a243af..8d28421d70d 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 062df68c0a4..10120a8805d 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 407f06f4894..7aa17520ba7 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, + // Maps the symbol value to the constant DefId. + symbol_map: FxHashMap, } -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> { + 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 3e39a47f196..548c4f7510a 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 2080a49a11c..c0b203b5388 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", "", "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.rs deleted file mode 100644 index 273288c3d52..00000000000 --- a/clippy_lints/src/utils/sym.rs +++ /dev/null @@ -1,6 +0,0 @@ -#[macro_export] -macro_rules! sym { - ($tt:tt) => { - rustc_span::symbol::Symbol::intern(stringify!($tt)) - }; -} diff --git a/clippy_lints/src/utils/sym_helper.rs b/clippy_lints/src/utils/sym_helper.rs new file mode 100644 index 00000000000..f47dc80ebad --- /dev/null +++ b/clippy_lints/src/utils/sym_helper.rs @@ -0,0 +1,7 @@ +#[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 b769a18802b..ebf69df31ca 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 00000000000..e632a7e57ee --- /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, +} + +#[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 { + 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 5683a71efea..10005a7fc81 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 337f7a229b9..af324f831df 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 60dfdb76650..1a7a30c61be 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 00000000000..fe8b080f56f --- /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 c579beeae89..72935072f8c 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 e490ee54c0b..f5f6c09ed8e 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 ec3af94b9ca..ea800336ef5 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 c6b84d2ef65..9ab845a573a 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 9ec82d4ad0b..a58e182971d 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 74b906c8a57..50c1c268eb1 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 00000000000..2ec0efe4c10 --- /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 00000000000..87e1b3a2ee7 --- /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 00000000000..b1284b7c8ff --- /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 18324823468..d6ecd8568ce 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 7c4e4a14551..24891682d36 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 4c08935639f..d011e84b115 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::(); + (&mut 1u8 as *mut u8).cast::(); + /* These should be ok */ // not a pointer type diff --git a/tests/ui/cast_alignment.stderr b/tests/ui/cast_alignment.stderr index 79219f86155..7998b787b91 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::(); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +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::(); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error: aborting due to 4 previous errors diff --git a/tests/ui/clone_on_copy.fixed b/tests/ui/clone_on_copy.fixed index 1f0ca101757..d924625132e 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 ca39a654b4f..97f49467244 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 14a700886a7..7a706884fb0 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 ce2a1c28c8a..fa4bc30e933 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 99c40b8d38e..bf6c1d1f894 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 3d1c458879e..ee3e11ae565 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 12428f29625..a2e5c13c452 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 466dfbe7cee..7125e5f602b 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 00000000000..386677352e2 --- /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 07004489610..d26f48fc68f 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) -> () {} #[rustfmt::skip] // Forces rustfmt to not add ABI pub extern fn do_not_warn_me_no_abi(_c_pointer: Box) -> () {} + +// Issue #4804 - default implementation in trait +mod issue4804 { + trait DefaultTraitImplTest { + // don't warn on `self` + fn default_impl(self: Box) -> u32 { + 5 + } + + // warn on `x: Box` + fn default_impl_x(self: Box, x: Box) -> u32 { + 4 + } + } + + trait WarnTrait { + // warn on `x: Box` + fn foo(x: Box) {} + } +} diff --git a/tests/ui/escape_analysis.stderr b/tests/ui/escape_analysis.stderr index c86a769a3da..4a82b4419f9 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>) -> () {} | ^^^^^^^^^^^ -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, x: Box) -> u32 { + | ^ + +error: local variable doesn't need to be boxed here + --> $DIR/escape_analysis.rs:202:16 + | +LL | fn foo(x: Box) {} + | ^ + +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 3e0921022b4..9fc208f5332 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, + 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 9a2bc778c3f..2f0f28f7bb7 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 18f56f85432..b101d2704fb 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 for String { -LL | | fn into(self) -> StringWrapper { -LL | | StringWrapper(self) -LL | | } -LL | | } - | |_^ +LL | impl Into 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 8d54f75b5d1..e83ce47e563 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 da2be6c8aa5..f98e30fa376 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 00000000000..70218f3f041 --- /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, +} + +struct TR { + magic: Result, +} + +fn simple_option_bad1(to: TO) -> Option { + // 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 { + // return as an expression + return to.magic +} + +fn simple_option_bad3(to: TO) -> Option { + // block value "return" + to.magic +} + +fn simple_option_bad4(to: Option) -> Option { + // 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) -> Option { + // closure with body + to.and_then(|t| { + t.magic + }) +} + +fn simple_result_bad1(tr: TR) -> Result { + 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 { + return tr.magic +} + +fn simple_result_bad3(tr: TR) -> Result { + tr.magic +} + +fn simple_result_bad4(tr: Result) -> Result { + 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) -> Result { + tr.and_then(|t| { + t.magic + }) +} + +fn also_bad(tr: Result) -> Result { + if tr.is_ok() { + let t = tr.unwrap(); + return t.magic; + } + Err(false) +} + +fn false_positive_test(x: Result<(), U>) -> Result<(), T> +where + T: From, +{ + Ok(x?) +} + +fn main() {} + +mod question_mark_none { + #![clippy::msrv = "1.12.0"] + fn needless_question_mark_option() -> Option { + struct TO { + magic: Option, + } + let to = TO { magic: None }; + Some(to.magic?) // should not be triggered + } + + fn needless_question_mark_result() -> Result { + struct TO { + magic: Result, + } + 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 { + struct TO { + magic: Option, + } + let to = TO { magic: None }; + Some(to.magic?) // should not be triggered + } + + fn needless_question_mark_result() -> Result { + struct TO { + magic: Result, + } + 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 { + struct TO { + magic: Option, + } + let to = TO { magic: None }; + to.magic // should be triggered + } + + fn needless_question_mark_result() -> Result { + struct TO { + magic: Result, + } + 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 00000000000..60ac2c8d72e --- /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, +} + +struct TR { + magic: Result, +} + +fn simple_option_bad1(to: TO) -> Option { + // 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 { + // return as an expression + return Some(to.magic?) +} + +fn simple_option_bad3(to: TO) -> Option { + // block value "return" + Some(to.magic?) +} + +fn simple_option_bad4(to: Option) -> Option { + // 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) -> Option { + // closure with body + to.and_then(|t| { + Some(t.magic?) + }) +} + +fn simple_result_bad1(tr: TR) -> Result { + 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 { + return Ok(tr.magic?) +} + +fn simple_result_bad3(tr: TR) -> Result { + Ok(tr.magic?) +} + +fn simple_result_bad4(tr: Result) -> Result { + 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) -> Result { + tr.and_then(|t| { + Ok(t.magic?) + }) +} + +fn also_bad(tr: Result) -> Result { + if tr.is_ok() { + let t = tr.unwrap(); + return Ok(t.magic?); + } + Err(false) +} + +fn false_positive_test(x: Result<(), U>) -> Result<(), T> +where + T: From, +{ + Ok(x?) +} + +fn main() {} + +mod question_mark_none { + #![clippy::msrv = "1.12.0"] + fn needless_question_mark_option() -> Option { + struct TO { + magic: Option, + } + let to = TO { magic: None }; + Some(to.magic?) // should not be triggered + } + + fn needless_question_mark_result() -> Result { + struct TO { + magic: Result, + } + 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 { + struct TO { + magic: Option, + } + let to = TO { magic: None }; + Some(to.magic?) // should not be triggered + } + + fn needless_question_mark_result() -> Result { + struct TO { + magic: Result, + } + 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 { + struct TO { + magic: Option, + } + let to = TO { magic: None }; + Some(to.magic?) // should be triggered + } + + fn needless_question_mark_result() -> Result { + struct TO { + magic: Result, + } + 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 00000000000..b4eb21882ec --- /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 d849e093da7..86bfc5b4bb2 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 29f2bd1852a..51061370dfe 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 00000000000..8346a9454f4 --- /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::(); + let _ = mut_ptr.cast::(); + + // Make sure the lint can handle the difference in their operator precedences. + unsafe { + let ptr_ptr: *const *const u32 = &ptr; + let _ = (*ptr_ptr).cast::(); + } + + // 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::(); + let _ = mut_ptr.cast::(); +} diff --git a/tests/ui/ptr_as_ptr.rs b/tests/ui/ptr_as_ptr.rs new file mode 100644 index 00000000000..b68d4bc0aac --- /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 00000000000..854906dc111 --- /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::()` + | + = 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::()` + +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::()` + +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::()` + +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::()` + +error: aborting due to 7 previous errors + diff --git a/tests/ui/try_err.fixed b/tests/ui/try_err.fixed index 652b611208b..5b96bb59c5f 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 6bd479657b7..f220d697d2c 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 9ad16d36509..b6a7bc5a1cc 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 c3a839a9bf8..094cff8c985 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 00000000000..642ce504009 --- /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 = Default::default(); + def_err.push(0); + + let mut new_err = Vec::::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 00000000000..819ed47d099 --- /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 = Default::default(); +LL | | def_err.push(0); + | |____________________^ help: consider using the `vec![]` macro: `let mut def_err: Vec = 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::::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 5282eba74fd..6cfc0fcb4ca 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 86467eb0fc7..32bd9075bd5 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 -- cgit 1.4.1-3-g733a5 From 8a77f63879e01525a6c2d3c0cbf43d2a7d36833b Mon Sep 17 00:00:00 2001 From: Philipp Krones Date: Fri, 15 Jan 2021 11:30:58 +0100 Subject: Fix formulations in label descriptions --- CONTRIBUTING.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index ed580e56055..f2641a23f56 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. -- cgit 1.4.1-3-g733a5 From 83f1abff4874a66124a6aaefec248ca4051c0d23 Mon Sep 17 00:00:00 2001 From: ThibsG Date: Mon, 4 Jan 2021 21:20:44 +0100 Subject: 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 63548d8fdb4..e438f92b136 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 86bfc5b4bb2..f137e8ecae9 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 51061370dfe..d754e4d37a8 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 f73c833a801..12d94e892ed 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 -- cgit 1.4.1-3-g733a5 From 46aa654c2d1792a42835d63f9a3dfcbffc20b758 Mon Sep 17 00:00:00 2001 From: ThibsG Date: Fri, 15 Jan 2021 18:58:48 +0100 Subject: 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 12d94e892ed..d1240e161c0 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: `{}` -- cgit 1.4.1-3-g733a5 From 837bc9906552af5da429bef4b37be588b8d2f49d Mon Sep 17 00:00:00 2001 From: Jason Newcomb Date: Thu, 31 Dec 2020 11:10:13 -0500 Subject: 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 b0e9ad55b4f..85f6929f924 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 4f9ebb4af3d..70fdfd22caa 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 00000000000..686298b6943 --- /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` + /// 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 00000000000..922b8b4ce57 --- /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 00000000000..9efd6484ad0 --- /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 + -- cgit 1.4.1-3-g733a5 From 2a41d40807ccf01268c29ba64ac9ea0efe1b26f7 Mon Sep 17 00:00:00 2001 From: Jason Newcomb Date: Thu, 31 Dec 2020 11:42:12 -0500 Subject: 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 e50d11a4d71..01126e86199 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` -- cgit 1.4.1-3-g733a5 From 27c0d6c14bde219bcaf72b4bcb6426f6f8650f6e Mon Sep 17 00:00:00 2001 From: Jason Newcomb Date: Thu, 31 Dec 2020 12:07:24 -0500 Subject: 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 686298b6943..5140b30a473 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; -- cgit 1.4.1-3-g733a5 From bf028b3f4a440bc8a390837da3a3f940177de1e6 Mon Sep 17 00:00:00 2001 From: Jason Newcomb Date: Thu, 31 Dec 2020 14:40:07 -0500 Subject: 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 5140b30a473..4478f559266 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; } -- cgit 1.4.1-3-g733a5 From 9146a77032e7d8c96ccae177c60ddb04b6159329 Mon Sep 17 00:00:00 2001 From: Jason Newcomb Date: Thu, 14 Jan 2021 21:38:57 +0000 Subject: Update clippy_lints/src/redundant_slicing.rs Co-authored-by: Philipp Krones --- 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 4478f559266..e5ced13514f 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, + ); } } } -- cgit 1.4.1-3-g733a5 From 7449dc96c0dd44dc5b309f24346976fea086e35d Mon Sep 17 00:00:00 2001 From: flip1995 Date: Sat, 16 Jan 2021 17:30:31 +0100 Subject: 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 3edbe723922..7607394b2fe 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 { } 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::>(); - 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 bec0c9f93a0..47b3cc3ad30 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 35b057d7b6a..aaa17561f06 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 e1ee8dbca2c..4a538021b98 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 edbb891afe0..3429317498e 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 1b859043bb5..94a667e5898 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 -- cgit 1.4.1-3-g733a5 From 38e293cf5d30a1609020c034d66e5aac3b844073 Mon Sep 17 00:00:00 2001 From: Jack Huey Date: Mon, 21 Dec 2020 22:49:03 -0500 Subject: 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 a435f86bfd8..ad50a6a0405 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::>(); -- cgit 1.4.1-3-g733a5 From 3436e21df5f728d9d784f48d0cc219737f9a222d Mon Sep 17 00:00:00 2001 From: Jack Huey Date: Wed, 23 Dec 2020 16:36:23 -0500 Subject: 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 ad50a6a0405..d2a3bd3921d 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 { -- cgit 1.4.1-3-g733a5 From f06eeaf9827895f9ad67f07c4a85669ce6a1bba7 Mon Sep 17 00:00:00 2001 From: Jack Huey Date: Mon, 4 Jan 2021 01:58:33 -0500 Subject: 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 d2a3bd3921d..9306b198051 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 { -- cgit 1.4.1-3-g733a5 From 7c3b6a63ade6ead9fc35d5fc20f53ea47f4eec71 Mon Sep 17 00:00:00 2001 From: Jack Huey Date: Mon, 4 Jan 2021 15:30:22 -0500 Subject: 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 9306b198051..6dc5654862b 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; } -- cgit 1.4.1-3-g733a5 From 82569601f2355f6cb5494031afac28bec2fefb78 Mon Sep 17 00:00:00 2001 From: Jack Huey Date: Mon, 4 Jan 2021 16:50:36 -0500 Subject: 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 6dc5654862b..3e87ef03832 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; -- cgit 1.4.1-3-g733a5 From e73b8dcbcaefe225f1c627905d29e6060375a665 Mon Sep 17 00:00:00 2001 From: Jack Huey Date: Thu, 7 Jan 2021 11:20:28 -0500 Subject: 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 +- clippy_lints/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 f9697afe405..a3a38fad9a3 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 6e8102790a5..f7231bba175 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 3e87ef03832..3b71f1b46e2 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 2501635e7ef..c6ae8b9b598 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> { 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 3e39a47f196..4c707c4b904 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 7cb7d0a26b6..a482017afeb 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; } -- cgit 1.4.1-3-g733a5 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: 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 78d23e1e0ef..52118a56bb6 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; -- cgit 1.4.1-3-g733a5 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: 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 52118a56bb6..6721639f724 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 { -- cgit 1.4.1-3-g733a5 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: 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 6721639f724..60a9fb59cd2 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; -- cgit 1.4.1-3-g733a5 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: 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 60a9fb59cd2..503cb82c3e5 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 5a285b0e714..59469ec5891 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 40ed18e9302..0c8aecc2d8c 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 fc502e9f71d..692abdb3054 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 d8205c5eb67..f5de7ea71d3 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 54a787fe555..4dcaaa474a8 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 -- cgit 1.4.1-3-g733a5 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: 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 0c8aecc2d8c..8665a3bb28a 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 692abdb3054..e284aece236 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 f5de7ea71d3..0a127858def 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 4dcaaa474a8..e54d89ecf29 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"); | ^^^^^^^ -- cgit 1.4.1-3-g733a5 From abb40c965f4986a346b157dba65d20da4a722813 Mon Sep 17 00:00:00 2001 From: Joshua Nelson Date: Sun, 17 Jan 2021 14:23:25 -0500 Subject: 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 3429317498e..f361db6b147 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 2fe1facf0c7..b8550078c46 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)] -- cgit 1.4.1-3-g733a5 From c3244c25ac5ccc2923105dfb903d6d4237ed1872 Mon Sep 17 00:00:00 2001 From: "kai.giebeler" Date: Sun, 17 Jan 2021 22:57:08 +0100 Subject: 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 68c5d32846f..e30970ed952 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 23fca43590b..e1c1aa85a60 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. | ^^^^^^^^^^^^^^^^^^^ -- cgit 1.4.1-3-g733a5 From dce2262daea813f67fb8cce4e76eb5909ef510cb Mon Sep 17 00:00:00 2001 From: LeSeulArtichaut Date: Sat, 12 Dec 2020 15:32:45 +0100 Subject: 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 38a0e27c4cf..ac9098a7584 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 166eadf86c1..640cffd24a7 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>) -> 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 fb80f48a9cc..ae56a8ba5ab 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 1fe4461533b..be646cbe4d0 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 ea986874291..40b236493a3 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 b0909f73177..d977cea4da5 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 3b5a83d2a0b..17cef0af3e9 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 9b262517a98..46b2b06d1a2 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 { } } -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 } -- cgit 1.4.1-3-g733a5 From 2454408318814a2451b0698fa6d1cbffcaafda5f Mon Sep 17 00:00:00 2001 From: Cameron Steffen Date: Mon, 18 Jan 2021 13:36:32 -0600 Subject: 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 f7224811e6e..6fa1378b8c7 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 cf528d189b4..a84f9c46287 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 7337d98c8be..91585927000 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 fd93548b55c..87954254610 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 db717cd1240..5886c2360e3 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 1c5ab2874b0..1ae2c6ca957 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 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 { 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 a0cfe145a30..42a92104a49 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 8c6fd10f98a..d34f9761e26 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 b1b5b3439a0..69302d695ce 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 { 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 3a9aa6ced03..f57d7536317 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 c53727ba160..fa508df865e 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 3b5a83d2a0b..624ea16f585 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, 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> { 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 7aa17520ba7..822863ca3e2 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 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 9b262517a98..023fb0a7112 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 { } } -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 { -- cgit 1.4.1-3-g733a5 From e33ab3fdd85e162909f884a2437cb42ce6e794cf Mon Sep 17 00:00:00 2001 From: ThibsG Date: Mon, 18 Jan 2021 22:33:25 +0100 Subject: 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 f137e8ecae9..990475fcb58 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 { + res.unwrap_or_else(|_| Foo) + } } fn main() { diff --git a/tests/ui/needless_return.rs b/tests/ui/needless_return.rs index d754e4d37a8..dec3d84a020 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 { + res.unwrap_or_else(|_| return Foo) + } } fn main() { diff --git a/tests/ui/needless_return.stderr b/tests/ui/needless_return.stderr index d1240e161c0..ae31d607541 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 -- cgit 1.4.1-3-g733a5 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: 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 0c8efd75514..c30d65bbc57 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 -- cgit 1.4.1-3-g733a5 From 3269070261e8324c2b3074cd491ddf2ac6cf19d3 Mon Sep 17 00:00:00 2001 From: nahuakang Date: Mon, 11 Jan 2021 23:56:12 +0100 Subject: 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 64864c2e278..a91b7c64770 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 f12994c7a60..17662b81205 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 00000000000..6d41ee38a27 --- /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 f13f2491d6e..018696ef0cf 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, } @@ -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 00000000000..7fe45c83bca --- /dev/null +++ b/tests/ui/inspect_for_each.rs @@ -0,0 +1,22 @@ +#![warn(clippy::inspect_for_each)] + +fn main() { + let a: Vec = vec![1, 2, 3, 4, 5]; + + let mut b: Vec = 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 00000000000..9f976bb7458 --- /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 + -- cgit 1.4.1-3-g733a5 From 966320642b157c539901ed0461d6aab6cb34729d Mon Sep 17 00:00:00 2001 From: Takayuki Nakata Date: Tue, 19 Jan 2021 23:51:10 +0900 Subject: 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 efe3237990d..2dfb947b5eb 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 f7b94118d4e..d927bae976f 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 4e585b9b96b..86bfb76ec26 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 d0a0f219097..436f4bcf738 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 -- cgit 1.4.1-3-g733a5 From 391bb218b5a79f32ddfacc668838fdfb06835f77 Mon Sep 17 00:00:00 2001 From: Marijn Suijten Date: Tue, 19 Jan 2021 19:20:26 +0100 Subject: 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. --- tests/ui/size_of_in_element_count.rs | 61 ------- tests/ui/size_of_in_element_count.stderr | 195 --------------------- tests/ui/size_of_in_element_count/expressions.rs | 28 +++ .../ui/size_of_in_element_count/expressions.stderr | 27 +++ tests/ui/size_of_in_element_count/functions.rs | 46 +++++ tests/ui/size_of_in_element_count/functions.stderr | 171 ++++++++++++++++++ 6 files changed, 272 insertions(+), 256 deletions(-) delete mode 100644 tests/ui/size_of_in_element_count.rs delete mode 100644 tests/ui/size_of_in_element_count.stderr create mode 100644 tests/ui/size_of_in_element_count/expressions.rs create mode 100644 tests/ui/size_of_in_element_count/expressions.stderr create mode 100644 tests/ui/size_of_in_element_count/functions.rs create mode 100644 tests/ui/size_of_in_element_count/functions.stderr diff --git a/tests/ui/size_of_in_element_count.rs b/tests/ui/size_of_in_element_count.rs deleted file mode 100644 index b13e390705a..00000000000 --- a/tests/ui/size_of_in_element_count.rs +++ /dev/null @@ -1,61 +0,0 @@ -#![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, slice_from_raw_parts, slice_from_raw_parts_mut, swap_nonoverlapping, write_bytes, -}; -use std::slice::{from_raw_parts, from_raw_parts_mut}; - -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 is size_of (Should trigger the lint) - unsafe { copy_nonoverlapping::(x.as_ptr(), y.as_mut_ptr(), size_of::()) }; - unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) }; - - unsafe { x.as_ptr().copy_to(y.as_mut_ptr(), size_of::()) }; - unsafe { x.as_ptr().copy_to_nonoverlapping(y.as_mut_ptr(), size_of::()) }; - unsafe { y.as_mut_ptr().copy_from(x.as_ptr(), size_of::()) }; - unsafe { y.as_mut_ptr().copy_from_nonoverlapping(x.as_ptr(), size_of::()) }; - - unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::()) }; - unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) }; - - unsafe { y.as_mut_ptr().write_bytes(0u8, size_of::() * SIZE) }; - unsafe { write_bytes(y.as_mut_ptr(), 0u8, size_of::() * SIZE) }; - - unsafe { swap_nonoverlapping(y.as_mut_ptr(), x.as_mut_ptr(), size_of::() * SIZE) }; - - slice_from_raw_parts_mut(y.as_mut_ptr(), size_of::() * SIZE); - slice_from_raw_parts(y.as_ptr(), size_of::() * SIZE); - - unsafe { from_raw_parts_mut(y.as_mut_ptr(), size_of::() * SIZE) }; - unsafe { from_raw_parts(y.as_ptr(), size_of::() * SIZE) }; - - unsafe { y.as_mut_ptr().sub(size_of::()) }; - y.as_ptr().wrapping_sub(size_of::()); - unsafe { y.as_ptr().add(size_of::()) }; - y.as_mut_ptr().wrapping_add(size_of::()); - unsafe { y.as_ptr().offset(size_of::() as isize) }; - y.as_mut_ptr().wrapping_offset(size_of::() 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::() * 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::() / 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::() / 2 * SIZE) }; -} diff --git a/tests/ui/size_of_in_element_count.stderr b/tests/ui/size_of_in_element_count.stderr deleted file mode 100644 index 8cf3612abda..00000000000 --- a/tests/ui/size_of_in_element_count.stderr +++ /dev/null @@ -1,195 +0,0 @@ -error: found a count of bytes instead of a count of elements of `T` - --> $DIR/size_of_in_element_count.rs:18:68 - | -LL | unsafe { copy_nonoverlapping::(x.as_ptr(), y.as_mut_ptr(), size_of::()) }; - | ^^^^^^^^^^^^^^^ - | - = 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/size_of_in_element_count.rs:19:62 - | -LL | unsafe { copy_nonoverlapping(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:21:49 - | -LL | unsafe { x.as_ptr().copy_to(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:22:64 - | -LL | unsafe { x.as_ptr().copy_to_nonoverlapping(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:23:51 - | -LL | unsafe { y.as_mut_ptr().copy_from(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:24:66 - | -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 - | -LL | unsafe { copy(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:27:47 - | -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 - | -LL | unsafe { y.as_mut_ptr().write_bytes(0u8, size_of::() * 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 - | -LL | unsafe { write_bytes(y.as_mut_ptr(), 0u8, size_of::() * 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 - | -LL | unsafe { swap_nonoverlapping(y.as_mut_ptr(), x.as_mut_ptr(), size_of::() * 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:34:46 - | -LL | slice_from_raw_parts_mut(y.as_mut_ptr(), size_of::() * 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 - | -LL | slice_from_raw_parts(y.as_ptr(), size_of::() * 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 - | -LL | unsafe { from_raw_parts_mut(y.as_mut_ptr(), size_of::() * 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 - | -LL | unsafe { from_raw_parts(y.as_ptr(), size_of::() * 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 - | -LL | unsafe { y.as_mut_ptr().sub(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:41:29 - | -LL | y.as_ptr().wrapping_sub(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:42:29 - | -LL | unsafe { y.as_ptr().add(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:43:33 - | -LL | y.as_mut_ptr().wrapping_add(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:44:32 - | -LL | unsafe { y.as_ptr().offset(size_of::() 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 - | -LL | y.as_mut_ptr().wrapping_offset(size_of::() 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::() * 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::() / 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 - 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 00000000000..b56910917ba --- /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::() * 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::() / 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::() / 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 00000000000..47b98e9d947 --- /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::() * 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::() / 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/functions.rs b/tests/ui/size_of_in_element_count/functions.rs new file mode 100644 index 00000000000..09d08ac37dc --- /dev/null +++ b/tests/ui/size_of_in_element_count/functions.rs @@ -0,0 +1,46 @@ +#![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, slice_from_raw_parts, slice_from_raw_parts_mut, swap_nonoverlapping, write_bytes, +}; +use std::slice::{from_raw_parts, from_raw_parts_mut}; + +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 is size_of (Should trigger the lint) + unsafe { copy_nonoverlapping::(x.as_ptr(), y.as_mut_ptr(), size_of::()) }; + unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) }; + + unsafe { x.as_ptr().copy_to(y.as_mut_ptr(), size_of::()) }; + unsafe { x.as_ptr().copy_to_nonoverlapping(y.as_mut_ptr(), size_of::()) }; + unsafe { y.as_mut_ptr().copy_from(x.as_ptr(), size_of::()) }; + unsafe { y.as_mut_ptr().copy_from_nonoverlapping(x.as_ptr(), size_of::()) }; + + unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::()) }; + unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) }; + + unsafe { y.as_mut_ptr().write_bytes(0u8, size_of::() * SIZE) }; + unsafe { write_bytes(y.as_mut_ptr(), 0u8, size_of::() * SIZE) }; + + unsafe { swap_nonoverlapping(y.as_mut_ptr(), x.as_mut_ptr(), size_of::() * SIZE) }; + + slice_from_raw_parts_mut(y.as_mut_ptr(), size_of::() * SIZE); + slice_from_raw_parts(y.as_ptr(), size_of::() * SIZE); + + unsafe { from_raw_parts_mut(y.as_mut_ptr(), size_of::() * SIZE) }; + unsafe { from_raw_parts(y.as_ptr(), size_of::() * SIZE) }; + + unsafe { y.as_mut_ptr().sub(size_of::()) }; + y.as_ptr().wrapping_sub(size_of::()); + unsafe { y.as_ptr().add(size_of::()) }; + y.as_mut_ptr().wrapping_add(size_of::()); + unsafe { y.as_ptr().offset(size_of::() as isize) }; + y.as_mut_ptr().wrapping_offset(size_of::() as isize); +} diff --git a/tests/ui/size_of_in_element_count/functions.stderr b/tests/ui/size_of_in_element_count/functions.stderr new file mode 100644 index 00000000000..c1e824167b7 --- /dev/null +++ b/tests/ui/size_of_in_element_count/functions.stderr @@ -0,0 +1,171 @@ +error: found a count of bytes instead of a count of elements of `T` + --> $DIR/functions.rs:18:68 + | +LL | unsafe { copy_nonoverlapping::(x.as_ptr(), y.as_mut_ptr(), size_of::()) }; + | ^^^^^^^^^^^^^^^ + | + = 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/functions.rs:19:62 + | +LL | unsafe { copy_nonoverlapping(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/functions.rs:21:49 + | +LL | unsafe { x.as_ptr().copy_to(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/functions.rs:22:64 + | +LL | unsafe { x.as_ptr().copy_to_nonoverlapping(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/functions.rs:23:51 + | +LL | unsafe { y.as_mut_ptr().copy_from(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/functions.rs:24:66 + | +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/functions.rs:26:47 + | +LL | unsafe { copy(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/functions.rs:27:47 + | +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/functions.rs:29:46 + | +LL | unsafe { y.as_mut_ptr().write_bytes(0u8, size_of::() * 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/functions.rs:30:47 + | +LL | unsafe { write_bytes(y.as_mut_ptr(), 0u8, size_of::() * 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/functions.rs:32:66 + | +LL | unsafe { swap_nonoverlapping(y.as_mut_ptr(), x.as_mut_ptr(), size_of::() * 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/functions.rs:34:46 + | +LL | slice_from_raw_parts_mut(y.as_mut_ptr(), size_of::() * 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/functions.rs:35:38 + | +LL | slice_from_raw_parts(y.as_ptr(), size_of::() * 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/functions.rs:37:49 + | +LL | unsafe { from_raw_parts_mut(y.as_mut_ptr(), size_of::() * 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/functions.rs:38:41 + | +LL | unsafe { from_raw_parts(y.as_ptr(), size_of::() * 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/functions.rs:40:33 + | +LL | unsafe { y.as_mut_ptr().sub(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/functions.rs:41:29 + | +LL | y.as_ptr().wrapping_sub(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/functions.rs:42:29 + | +LL | unsafe { y.as_ptr().add(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/functions.rs:43:33 + | +LL | y.as_mut_ptr().wrapping_add(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/functions.rs:44:32 + | +LL | unsafe { y.as_ptr().offset(size_of::() 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/functions.rs:45:36 + | +LL | y.as_mut_ptr().wrapping_offset(size_of::() 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: aborting due to 21 previous errors + -- cgit 1.4.1-3-g733a5 From d4bf59b6ef24042653951b69105a3a68542f3bbd Mon Sep 17 00:00:00 2001 From: Marijn Suijten Date: Tue, 12 Jan 2021 11:35:44 +0100 Subject: 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 +++++++++ tests/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 ea7a76146f5..87e386baadc 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> { +fn get_size_of_ty(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, inverted: bool) -> Option> { 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 { - 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 b56910917ba..2594e8fa6ad 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::() / 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::()) }; + + // 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::())) }; + + // 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::())) }; + // 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 47b98e9d947..0f0dff57f51 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::() | = 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::())) }; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = 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 -- cgit 1.4.1-3-g733a5 From 6c830ff9e4621c6e159ce8edb33fb225352e7b69 Mon Sep 17 00:00:00 2001 From: Hirochika Matsumoto Date: Sat, 19 Dec 2020 18:57:11 +0900 Subject: 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 b3adeed7720..963c9e77a18 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 00000000000..835e92dc04b --- /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 0b1b347ce42..a236e1b54bb 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 00000000000..bf5ab9f8bb7 --- /dev/null +++ b/tests/ui/capitalized_acronyms.rs @@ -0,0 +1,5 @@ +#![warn(clippy::capitalized_acronyms)] + +fn main() { + // test code goes here +} -- cgit 1.4.1-3-g733a5 From ab1da8f86569e55d4b33702c6a062551f8abdd6e Mon Sep 17 00:00:00 2001 From: Hirochika Matsumoto Date: Sat, 19 Dec 2020 22:50:45 +0900 Subject: 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 963c9e77a18..04f042b2deb 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 835e92dc04b..00000000000 --- 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 b3ebdf4ca30..f21a734bb43 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 c629ee05ab9..260b8988d37 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 a236e1b54bb..9b73c249643 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 44e739725c8..90cf1b6c861 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 00000000000..61e7031716a --- /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::(); + let fragments = ident + .split_inclusive(|x: char| !x.is_ascii_lowercase()) + .rev() + .map(|x| x.chars().rev().collect::()); + + 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 bf5ab9f8bb7..00000000000 --- 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 be61fb6b9be..383bbb49dbe 100644 --- a/tests/ui/complex_types.rs +++ b/tests/ui/complex_types.rs @@ -11,7 +11,7 @@ struct S { f: Vec>>, } -struct TS(Vec>>); +struct Ts(Vec>>); enum E { Tuple(Vec>>), diff --git a/tests/ui/complex_types.stderr b/tests/ui/complex_types.stderr index 8f5dbd27956..7fcbb4bce88 100644 --- a/tests/ui/complex_types.stderr +++ b/tests/ui/complex_types.stderr @@ -21,7 +21,7 @@ LL | f: Vec>>, error: very complex type used. Consider factoring parts into `type` definitions --> $DIR/complex_types.rs:14:11 | -LL | struct TS(Vec>>); +LL | struct Ts(Vec>>); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 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 6f60d45d68a..5409f36b3f1 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 0e8353a418a..d1a8bdc3c8d 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 01774a2a984..89d99dcf0c8 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 70218f3f041..71fb3565224 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 60ac2c8d72e..e31f6f48fa7 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 b4eb21882ec..567bc518a3f 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 dd6f4ec7bd9..2f8c7cec50f 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 26b03bdc740..9e213aab68c 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 b39e891094f..13a036cd800 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 096f5a71150..4a10cc702c4 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 00000000000..af0b5776348 --- /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 00000000000..2065fe10bb1 --- /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 d6a890014e6..bb2012441d9 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 b04d9ce75b2..ddfd2beba31 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() {} -- cgit 1.4.1-3-g733a5 From 0ccb491caa668d55522c1bc78e368329a310db4c Mon Sep 17 00:00:00 2001 From: Hirochika Matsumoto Date: Wed, 20 Jan 2021 18:14:09 +0900 Subject: Remove nightly-gate of `split_inclusive` Co-authored-by: Philipp Krones --- 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 9b73c249643..53764bb7390 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)] -- cgit 1.4.1-3-g733a5 From 2be935d396a650a1480859a75011a742df882c74 Mon Sep 17 00:00:00 2001 From: Aaron Hill Date: Mon, 18 Jan 2021 16:47:37 -0500 Subject: 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 f518da55cd7..3a754f49917 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(..) -- cgit 1.4.1-3-g733a5 From e42208f1b7befe316e32c66b6dc6d242a56f4d84 Mon Sep 17 00:00:00 2001 From: pastchick3 <331604390@qq.com> Date: Wed, 20 Jan 2021 20:05:25 +0800 Subject: 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 99e4b293ac6..276a9338819 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 780389f32bc..b8d22ed2504 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 -- cgit 1.4.1-3-g733a5 From f1ab3024b27cc7c02a80fd54382a10a1b4ef3bcd Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Thu, 21 Jan 2021 12:48:30 -0800 Subject: 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 04f042b2deb..4cf2125ea2f 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 00000000000..099171962d3 --- /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 53764bb7390..465ad3846ce 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 00000000000..2d5f0474bc0 --- /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 00000000000..5c88454ae61 --- /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 00000000000..ee5a1836267 --- /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 + -- cgit 1.4.1-3-g733a5 From dc93188805ac20fbccd7bd616a6b114680e9303a Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Thu, 21 Jan 2021 13:31:15 -0800 Subject: 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 099171962d3..1391ebd9e31 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 465ad3846ce..becd9f333fd 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); -- cgit 1.4.1-3-g733a5 From f6cb96ef07ac6197dac5be16adbe2b7950c82d99 Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Thu, 21 Jan 2021 13:34:44 -0800 Subject: 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 1391ebd9e31..2e1c0728d2c 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 2d5f0474bc0..71c4a251e3b 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 5c88454ae61..45af6851dd1 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 ee5a1836267..280c40b00aa 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, -- cgit 1.4.1-3-g733a5 From 09d4d49299c6614a0ae956980e709a234d21a9ef Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Thu, 21 Jan 2021 13:36:18 -0800 Subject: ExhaustiveEnums -> ExhaustiveItems --- clippy_lints/src/exhaustive_enums.rs | 69 ------------------------------------ clippy_lints/src/exhaustive_items.rs | 69 ++++++++++++++++++++++++++++++++++++ clippy_lints/src/lib.rs | 8 ++--- tests/ui/exhaustive_enums.fixed | 42 ---------------------- tests/ui/exhaustive_enums.rs | 41 --------------------- tests/ui/exhaustive_enums.stderr | 28 --------------- tests/ui/exhaustive_items.fixed | 42 ++++++++++++++++++++++ tests/ui/exhaustive_items.rs | 41 +++++++++++++++++++++ tests/ui/exhaustive_items.stderr | 28 +++++++++++++++ 9 files changed, 184 insertions(+), 184 deletions(-) delete mode 100644 clippy_lints/src/exhaustive_enums.rs create mode 100644 clippy_lints/src/exhaustive_items.rs delete mode 100644 tests/ui/exhaustive_enums.fixed delete mode 100644 tests/ui/exhaustive_enums.rs delete mode 100644 tests/ui/exhaustive_enums.stderr create mode 100644 tests/ui/exhaustive_items.fixed create mode 100644 tests/ui/exhaustive_items.rs create mode 100644 tests/ui/exhaustive_items.stderr diff --git a/clippy_lints/src/exhaustive_enums.rs b/clippy_lints/src/exhaustive_enums.rs deleted file mode 100644 index 2e1c0728d2c..00000000000 --- a/clippy_lints/src/exhaustive_enums.rs +++ /dev/null @@ -1,69 +0,0 @@ -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_lint::{LateContext, LateLintPass}; -use rustc_session::{declare_lint_pass, declare_tool_lint}; -use rustc_span::sym; - -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. - /// - /// **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 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) { - 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/exhaustive_items.rs b/clippy_lints/src/exhaustive_items.rs new file mode 100644 index 00000000000..0fa6c4b589f --- /dev/null +++ b/clippy_lints/src/exhaustive_items.rs @@ -0,0 +1,69 @@ +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_lint::{LateContext, LateLintPass}; +use rustc_session::{declare_lint_pass, declare_tool_lint}; +use rustc_span::sym; + +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. + /// + /// **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!(ExhaustiveItems => [EXHAUSTIVE_ENUMS]); + +impl LateLintPass<'_> for ExhaustiveItems { + 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) { + 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 becd9f333fd..a5deebf7d5f 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_enums.fixed deleted file mode 100644 index 71c4a251e3b..00000000000 --- a/tests/ui/exhaustive_enums.fixed +++ /dev/null @@ -1,42 +0,0 @@ -// run-rustfix - -#![deny(clippy::exhaustive_enums)] -#![allow(unused)] - -fn main() { - // nop -} - -#[non_exhaustive] -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, private -enum ExhaustivePrivate { - Foo, - Bar, - Baz, - Quux(String), -} - -// no warning, private -#[non_exhaustive] -enum NonExhaustivePrivate { - Foo, - Bar, - Baz, - Quux(String), -} diff --git a/tests/ui/exhaustive_enums.rs b/tests/ui/exhaustive_enums.rs deleted file mode 100644 index 45af6851dd1..00000000000 --- a/tests/ui/exhaustive_enums.rs +++ /dev/null @@ -1,41 +0,0 @@ -// run-rustfix - -#![deny(clippy::exhaustive_enums)] -#![allow(unused)] - -fn main() { - // nop -} - -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, private -enum ExhaustivePrivate { - Foo, - Bar, - Baz, - Quux(String), -} - -// no warning, private -#[non_exhaustive] -enum NonExhaustivePrivate { - Foo, - Bar, - Baz, - Quux(String), -} diff --git a/tests/ui/exhaustive_enums.stderr b/tests/ui/exhaustive_enums.stderr deleted file mode 100644 index 280c40b00aa..00000000000 --- a/tests/ui/exhaustive_enums.stderr +++ /dev/null @@ -1,28 +0,0 @@ -error: enums should not be exhaustive - --> $DIR/exhaustive_enums.rs:10:1 - | -LL | / pub 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 | pub enum Exhaustive { -LL | Foo, -LL | Bar, -LL | Baz, -LL | Quux(String), - ... - -error: aborting due to previous error - diff --git a/tests/ui/exhaustive_items.fixed b/tests/ui/exhaustive_items.fixed new file mode 100644 index 00000000000..71c4a251e3b --- /dev/null +++ b/tests/ui/exhaustive_items.fixed @@ -0,0 +1,42 @@ +// run-rustfix + +#![deny(clippy::exhaustive_enums)] +#![allow(unused)] + +fn main() { + // nop +} + +#[non_exhaustive] +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, private +enum ExhaustivePrivate { + Foo, + Bar, + Baz, + Quux(String), +} + +// no warning, private +#[non_exhaustive] +enum NonExhaustivePrivate { + Foo, + Bar, + Baz, + Quux(String), +} diff --git a/tests/ui/exhaustive_items.rs b/tests/ui/exhaustive_items.rs new file mode 100644 index 00000000000..45af6851dd1 --- /dev/null +++ b/tests/ui/exhaustive_items.rs @@ -0,0 +1,41 @@ +// run-rustfix + +#![deny(clippy::exhaustive_enums)] +#![allow(unused)] + +fn main() { + // nop +} + +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, private +enum ExhaustivePrivate { + Foo, + Bar, + Baz, + Quux(String), +} + +// no warning, private +#[non_exhaustive] +enum NonExhaustivePrivate { + Foo, + Bar, + Baz, + Quux(String), +} diff --git a/tests/ui/exhaustive_items.stderr b/tests/ui/exhaustive_items.stderr new file mode 100644 index 00000000000..d00d950efc7 --- /dev/null +++ b/tests/ui/exhaustive_items.stderr @@ -0,0 +1,28 @@ +error: enums should not be exhaustive + --> $DIR/exhaustive_items.rs:10:1 + | +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 + | +LL | #![deny(clippy::exhaustive_enums)] + | ^^^^^^^^^^^^^^^^^^^^^^^^ +help: try adding #[non_exhaustive] + | +LL | #[non_exhaustive] +LL | pub enum Exhaustive { +LL | Foo, +LL | Bar, +LL | Baz, +LL | Quux(String), + ... + +error: aborting due to previous error + -- cgit 1.4.1-3-g733a5 From a905cf6737197096e2aa1b8f384b07ded9e96fd1 Mon Sep 17 00:00:00 2001 From: xFrednet Date: Fri, 22 Jan 2021 00:19:22 +0100 Subject: 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 954474a17aa..8f2a20bfe24 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 . + +## 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 -- cgit 1.4.1-3-g733a5 From 2d509f8b404b77fd7fa949a13fd38c9f5f51b9fb Mon Sep 17 00:00:00 2001 From: Cameron Steffen Date: Thu, 21 Jan 2021 18:12:46 -0600 Subject: 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 a34ba2d00a8..c75aa2bde97 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 { -- cgit 1.4.1-3-g733a5 From e89ad4ba71816cbe6fb1f90743d9229fc824b1c0 Mon Sep 17 00:00:00 2001 From: Cameron Steffen Date: Mon, 14 Dec 2020 13:50:53 -0600 Subject: 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 623554ea2d1..c8b69f4fbae 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"; -- cgit 1.4.1-3-g733a5 From 7a8660861ecf11474e03823387a50eeaa2c18a57 Mon Sep 17 00:00:00 2001 From: Cameron Steffen Date: Fri, 1 Jan 2021 13:00:44 -0600 Subject: 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 10120a8805d..1c7398f17f2 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, &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 { -- cgit 1.4.1-3-g733a5 From c92bdc4dbbd777f6933f7990f87066147a629c8d Mon Sep 17 00:00:00 2001 From: Cameron Steffen Date: Fri, 1 Jan 2021 13:00:09 -0600 Subject: 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 04f042b2deb..8feb1a148af 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 53764bb7390..bde9c630c6c 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 c8b69f4fbae..518d2e67ad1 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 11922681379..c7b4f28be3a 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 00000000000..fc8f58f8ea5 --- /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) -> Option { + unimplemented!() +} + +fn to_res(_: T) -> Result { + unimplemented!() +} diff --git a/tests/ui/manual_filter_map.rs b/tests/ui/manual_filter_map.rs new file mode 100644 index 00000000000..3af4bbee3bf --- /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) -> Option { + unimplemented!() +} + +fn to_res(_: T) -> Result { + unimplemented!() +} diff --git a/tests/ui/manual_filter_map.stderr b/tests/ui/manual_filter_map.stderr new file mode 100644 index 00000000000..4d4e2d5c12f --- /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 + -- cgit 1.4.1-3-g733a5 From a752d31e0a8cd8c7d8549daf421a8b791d1325a4 Mon Sep 17 00:00:00 2001 From: Cameron Steffen Date: Thu, 14 Jan 2021 16:36:36 -0600 Subject: 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 8feb1a148af..7f2de888d35 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 bde9c630c6c..b22ddfacf86 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 518d2e67ad1..9d078588746 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 aea3cc62afc..00000000000 --- 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 = a.iter().find(|s| s.parse::().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 = 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 00000000000..95e97c4fd1f --- /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) -> Option { + unimplemented!() +} + +fn to_res(_: T) -> Result { + unimplemented!() +} diff --git a/tests/ui/manual_find_map.rs b/tests/ui/manual_find_map.rs new file mode 100644 index 00000000000..cd3c82e3b25 --- /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) -> Option { + unimplemented!() +} + +fn to_res(_: T) -> Result { + unimplemented!() +} diff --git a/tests/ui/manual_find_map.stderr b/tests/ui/manual_find_map.stderr new file mode 100644 index 00000000000..9e7f798df45 --- /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 + -- cgit 1.4.1-3-g733a5 From a22915bf4893e16d64100365d902e52211374a0c Mon Sep 17 00:00:00 2001 From: Cameron Steffen Date: Mon, 14 Dec 2020 14:03:11 -0600 Subject: 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 5f5048e79e7..a8a6a2cb1bd 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 1c5ab2874b0..c7e1088e353 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, &'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 { -- cgit 1.4.1-3-g733a5 From 82bab19a0105ff86176b79a5eae7a9ea7d300cb9 Mon Sep 17 00:00:00 2001 From: Cameron Steffen Date: Thu, 14 Jan 2021 16:47:22 -0600 Subject: 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 bec0c9f93a0..ea386237f20 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 b22ddfacf86..7097812e088 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 9d078588746..7a459a440ca 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, -- cgit 1.4.1-3-g733a5 From 612a7fc18eba9410aa18ba331f2ba982b8875066 Mon Sep 17 00:00:00 2001 From: Esteban Küber Date: Wed, 20 Jan 2021 17:15:08 -0800 Subject: 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 1c5ab2874b0..bbcea387de2 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 a971d041ca6..bb4d8483404 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 24da056770c..d5b1767e945 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) => { -- cgit 1.4.1-3-g733a5 From 3a5ede6ef4b4ef6ae6c6f2c583d4c6620a95fd30 Mon Sep 17 00:00:00 2001 From: Esteban Küber Date: Thu, 21 Jan 2021 16:48:17 -0800 Subject: 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 bb4d8483404..603071a5f4a 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 43afa65de3e..ca60d335262 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 9b3585865da..42ab9a1e7d2 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 10120a8805d..6066383f2ef 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); -- cgit 1.4.1-3-g733a5 From 23662d1353a52be7c35bb3905337f2aadf7c504a Mon Sep 17 00:00:00 2001 From: Takayuki Nakata Date: Fri, 22 Jan 2021 22:51:06 +0900 Subject: 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 2dfb947b5eb..e1450466a7c 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." -- cgit 1.4.1-3-g733a5 From 8c00304bbbe79a940b838039f8d679fd70c6b137 Mon Sep 17 00:00:00 2001 From: flip1995 Date: Fri, 22 Jan 2021 18:07:00 +0100 Subject: 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 9f389c8d2f9..527905e375d 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 c0b203b5388..432cc5b59f6 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"]; -- cgit 1.4.1-3-g733a5 From 8cb7e85006853e99e6ba2bf378c801fb53eee8fa Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Thu, 21 Jan 2021 13:41:57 -0800 Subject: 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 4cf2125ea2f..ccc7eb7e881 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 0fa6c4b589f..d604ad0004f 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 a5deebf7d5f..91c74026f64 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 71c4a251e3b..bc146c6afc5 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 45af6851dd1..ed86b50be30 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 d00d950efc7..7e286e65949 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 -- cgit 1.4.1-3-g733a5 From 752274eabdd9be991c9a4e11850890301b697032 Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Thu, 21 Jan 2021 14:00:25 -0800 Subject: 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 d604ad0004f..bbcf9bfea27 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 bc146c6afc5..7e355d2a58b 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 7e286e65949..1716c8e2cb5 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 | } -- cgit 1.4.1-3-g733a5 From 65d003a1128e9234730a66c79065afdabb31afa0 Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Fri, 22 Jan 2021 12:08:46 -0800 Subject: 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 bbcf9bfea27..4749e36238c 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 1716c8e2cb5..a24e64b6705 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 -- cgit 1.4.1-3-g733a5 From 66afdd1f4292e7fda6ea89113c0c8343e3321d99 Mon Sep 17 00:00:00 2001 From: Cameron Steffen Date: Thu, 21 Jan 2021 19:21:12 -0600 Subject: 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 c75aa2bde97..604ba102046 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 { .. } - 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 { + 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 d571ac4ab69..8372a212477 100644 --- a/tests/ui/collapsible_match2.rs +++ b/tests/ui/collapsible_match2.rs @@ -40,6 +40,35 @@ fn lint_cases(opt_opt: Option>, res_opt: Result, 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 { diff --git a/tests/ui/collapsible_match2.stderr b/tests/ui/collapsible_match2.stderr index 490d82d12cd..b2eb457d173 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 -- cgit 1.4.1-3-g733a5 From 50abde20c901cf815480f0b494234025c315cc7f Mon Sep 17 00:00:00 2001 From: Cameron Steffen Date: Thu, 21 Jan 2021 19:25:22 -0600 Subject: 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 eceae706e4f..1ed3f3de839 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 c6329a1381c..b5aa3411140 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 9b3585865da..bb71d95a7e2 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 8698a618f90..991fae6b1aa 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 -- cgit 1.4.1-3-g733a5 From bec916d02dc3e330e0dc055080207d708978b41d Mon Sep 17 00:00:00 2001 From: Matthias Krüger Date: Fri, 18 Dec 2020 13:21:13 +0100 Subject: 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 00000000000..fe0fc440316 --- /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 = 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 = krates.into_iter().map(|krate| krate.download_and_extract()).map(|krate| krate.run_clippy_lints()).collect::>(); +} diff --git a/clippy_dev/src/lib.rs b/clippy_dev/src/lib.rs index 17cc08ee10f..4873769b367 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; -- cgit 1.4.1-3-g733a5 From 5353591b1bc7e4fcb886afcd7944619607adb5cb Mon Sep 17 00:00:00 2001 From: Matthias Krüger Date: Fri, 18 Dec 2020 14:14:15 +0100 Subject: 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 b8a4a20114b..517e9d250bc 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 "] 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 fe0fc440316..22b04242885 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 = krates.into_iter().map(|krate| krate.download_and_extract()).map(|krate| krate.run_clippy_lints()).collect::>(); + // download and extract the crates, then run clippy on them and collect clippys warnings + let clippy_lint_results: Vec = krates + .into_iter() + .map(|krate| krate.download_and_extract()) + .map(|krate| krate.run_clippy_lints()) + .collect::>(); } -- cgit 1.4.1-3-g733a5 From 30d85942cf4fee5148a6b994c9ec8bd1190a5122 Mon Sep 17 00:00:00 2001 From: Matthias Krüger Date: Fri, 18 Dec 2020 14:28:59 +0100 Subject: 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 22b04242885..1cf12941c35 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 = krates + let _clippy_lint_results: Vec = 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 2ea56c42faf..6fb8b6f2899 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") -- cgit 1.4.1-3-g733a5 From 63176834c2a9cc6718a4e7b20238b607331f1f1d Mon Sep 17 00:00:00 2001 From: Matthias Krüger Date: Fri, 18 Dec 2020 16:17:53 +0100 Subject: 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 1cf12941c35..cade6c38bc1 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 = 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 -- cgit 1.4.1-3-g733a5 From e69147486ecf0335176fedfca4914a6161436293 Mon Sep 17 00:00:00 2001 From: Matthias Krüger Date: Fri, 18 Dec 2020 16:53:18 +0100 Subject: 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 cade6c38bc1..b18c4edc236 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 -- cgit 1.4.1-3-g733a5 From 69c0757334806f0cd0bf680428959723b042555b Mon Sep 17 00:00:00 2001 From: Matthias Krüger Date: Fri, 18 Dec 2020 17:25:07 +0100 Subject: 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 b18c4edc236..d7ed95dfe86 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 = vec![KrateSource::new("cargo", "0.49.0"), KrateSource::new("regex", "1.4.2")]; + let krates: Vec = 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 = 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::>(); } -- cgit 1.4.1-3-g733a5 From 2360a7cad05242ae161a6903d03085c57aa1a099 Mon Sep 17 00:00:00 2001 From: Matthias Krüger Date: Fri, 18 Dec 2020 18:01:45 +0100 Subject: 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 d7ed95dfe86..3ac62f7ebc7 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 = vec![KrateSource::new("regex", "1.4.2"), KrateSource::new("cargo", "0.49.0"), ]; + let krates: Vec = 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 = krates + let clippy_lint_results: Vec = krates .into_iter() .map(|krate| krate.download_and_extract()) .map(|krate| krate.run_clippy_lints(&cargo_clippy_path)) .collect::>(); + dbg!(clippy_lint_results); } -- cgit 1.4.1-3-g733a5 From 734d2052df123db0ed0ff05a7ab0f0d9271d18c5 Mon Sep 17 00:00:00 2001 From: Matthias Krüger Date: Fri, 18 Dec 2020 18:34:09 +0100 Subject: 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 3ac62f7ebc7..6b121a79e37 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 { 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 = 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 = krates + let clippy_lint_results: Vec> = krates .into_iter() .map(|krate| krate.download_and_extract()) .map(|krate| krate.run_clippy_lints(&cargo_clippy_path)) - .collect::>(); - dbg!(clippy_lint_results); + .collect(); + + let results: Vec = clippy_lint_results.into_iter().flatten().collect(); + + results.iter().for_each(|l| println!("{}", l)); } -- cgit 1.4.1-3-g733a5 From 73141337223bfa55d03f2d1097af6a036a6cbbc5 Mon Sep 17 00:00:00 2001 From: Matthias Krüger Date: Fri, 18 Dec 2020 20:58:46 +0100 Subject: 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 6b121a79e37..63c04f9a1f1 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 { + 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 = output + let stderr = String::from_utf8_lossy(&all_output.stderr); + let output_lines = stderr.lines(); + let mut output: Vec = 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 = 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> = krates @@ -125,7 +140,8 @@ pub fn run() { .map(|krate| krate.run_clippy_lints(&cargo_clippy_path)) .collect(); - let results: Vec = clippy_lint_results.into_iter().flatten().collect(); + let all_warnings: Vec = 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)); } -- cgit 1.4.1-3-g733a5 From dbb8c0020e76e448f96b1b346dab5afd0d08ce40 Mon Sep 17 00:00:00 2001 From: Matthias Krüger Date: Fri, 18 Dec 2020 21:26:41 +0100 Subject: 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 63c04f9a1f1..3fb130cc594 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 = 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(); } -- cgit 1.4.1-3-g733a5 From 728dc06d88fe276c1368b2c5d99cb3b4df49171c Mon Sep 17 00:00:00 2001 From: Matthias Krüger Date: Fri, 18 Dec 2020 21:27:17 +0100 Subject: 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 00000000000..48296dbd479 --- /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` -- cgit 1.4.1-3-g733a5 From 1e5ac1dfd215f554c5b7980c21fb7eda5f4c526e Mon Sep 17 00:00:00 2001 From: Matthias Krüger Date: Fri, 18 Dec 2020 21:50:06 +0100 Subject: 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 3fb130cc594..b23d9b4d987 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 = vec![KrateSource::new("regex", "1.4.2"), KrateSource::new("cargo", "0.49.0")]; + let krates: Vec = 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 48296dbd479..b32d9f30d42 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` 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` -- cgit 1.4.1-3-g733a5 From ccfaa338edead678687dcd690846470cbeee1dcd Mon Sep 17 00:00:00 2001 From: Matthias Krüger Date: Fri, 18 Dec 2020 22:08:18 +0100 Subject: 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 b23d9b4d987..eb301159a7b 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 b32d9f30d42..963b1fa38bf 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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` instead of `Option>` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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` instead of `Option>` 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` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` instead +regex-1.4.2/src/expand.rs:42:21: called `map().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` instead +regex-1.4.2/src/expand.rs:84:21: called `map().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` instead +regex-1.4.2/src/re_bytes.rs:1045:9: called `map().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` instead +regex-1.4.2/src/re_unicode.rs:1047:9: called `map().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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 -- cgit 1.4.1-3-g733a5 From a9fce6d2d0528c9d8cf6390c3e00a3a6099687ce Mon Sep 17 00:00:00 2001 From: Matthias Krüger Date: Fri, 18 Dec 2020 22:53:45 +0100 Subject: 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 eb301159a7b..631499395df 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 { -- cgit 1.4.1-3-g733a5 From 588efa7da9af41e79f51935efeb9919ccef97f44 Mon Sep 17 00:00:00 2001 From: Matthias Krüger Date: Tue, 22 Dec 2020 13:07:55 +0100 Subject: 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 517e9d250bc..6c6941837f1 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 00000000000..e69056c9925 --- /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 631499395df..f64ab897906 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, +} + // 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 { + 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 = 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> = krates + + let clippy_lint_results: Vec> = read_crates() .into_iter() .map(|krate| krate.download_and_extract()) .map(|krate| krate.run_clippy_lints(&cargo_clippy_path)) .collect(); - let all_warnings: Vec = clippy_lint_results.into_iter().flatten().collect(); + let mut all_warnings: Vec = 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 963b1fa38bf..dfa6450def7 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` instead of `Option>` 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` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` instead -regex-1.4.2/src/expand.rs:42:21: called `map().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` instead -regex-1.4.2/src/expand.rs:84:21: called `map().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` instead -regex-1.4.2/src/re_bytes.rs:1045:9: called `map().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` instead -regex-1.4.2/src/re_unicode.rs:1047:9: called `map().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` instead +regex-1.3.2/src/expand.rs:42:21: called `map().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` instead +regex-1.3.2/src/expand.rs:84:21: called `map().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` instead +regex-1.3.2/src/re_bytes.rs:1039:9: called `map().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` instead +regex-1.3.2/src/re_unicode.rs:1041:9: called `map().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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` instead of `Option>` 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) -- cgit 1.4.1-3-g733a5 From f986d78c5e6d401ea3c57c7d00d24d1890675f0c Mon Sep 17 00:00:00 2001 From: Matthias Krüger Date: Wed, 23 Dec 2020 01:21:31 +0100 Subject: 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 e69056c9925..1fbf7930d3e 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 f64ab897906..a681bf10496 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, +} + // 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, + crates: HashMap>, } // represents the extracted sourcecode of a crate @@ -145,11 +152,24 @@ fn read_crates() -> Vec { 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 = 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 -- cgit 1.4.1-3-g733a5 From 22824d21da0397d61c15a56dbb88405f4866293d Mon Sep 17 00:00:00 2001 From: Matthias Krüger Date: Wed, 23 Dec 2020 13:02:02 +0100 Subject: 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 a681bf10496..6202acfad06 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, } // 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 { 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 { +// get a list of CrateSources we want to check from a "crater_crates.toml" file. +fn read_crates() -> Vec { 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 = crate_list + let tomlcrates: Vec = 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 -- cgit 1.4.1-3-g733a5 From 62337f284281637a73a8d4770315850fbf4067aa Mon Sep 17 00:00:00 2001 From: Matthias Krüger Date: Wed, 23 Dec 2020 13:03:19 +0100 Subject: 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 6c6941837f1..e41ed77fcb9 100644 --- a/clippy_dev/Cargo.toml +++ b/clippy_dev/Cargo.toml @@ -1,8 +1,8 @@ [package] -authors = ["Philipp Hansch "] -edition = "2018" name = "clippy_dev" version = "0.0.1" +authors = ["Philipp Hansch "] +edition = "2018" [dependencies] bytecount = "0.6" diff --git a/clippy_dev/src/crater.rs b/clippy_dev/src/crater.rs index 6202acfad06..8a6ce0a8921 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>, +} + +// 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, @@ -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>, -} - // 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 dfa6450def7..42d978f4db4 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 -- cgit 1.4.1-3-g733a5 From 6c5bf2778fa09fd3a79dd2fa76779c07ee182391 Mon Sep 17 00:00:00 2001 From: Matthias Krüger Date: Wed, 23 Dec 2020 15:00:51 +0100 Subject: 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 e41ed77fcb9..d6663145142 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 8a6ce0a8921..db0dd3641f1 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 = output_lines + let stdout = String::from_utf8_lossy(&all_output.stdout); + let output_lines = stdout.lines(); + //dbg!(&output_lines); + let warnings: Vec = 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 = 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 { 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 42d978f4db4..52045f05faa 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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` instead of `Option>` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` instead -regex-1.3.2/src/expand.rs:42:21: called `map().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` instead -regex-1.3.2/src/expand.rs:84:21: called `map().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` instead -regex-1.3.2/src/re_bytes.rs:1039:9: called `map().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` instead -regex-1.3.2/src/re_unicode.rs:1041:9: called `map().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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` instead of `Option>` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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` instead of `Option>` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` instead" +regex/1.3.2/src/expand.rs:42:21 clippy::map_unwrap_or "called `map().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` instead" +regex/1.3.2/src/expand.rs:84:21 clippy::map_unwrap_or "called `map().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` instead" +regex/1.3.2/src/re_bytes.rs:1039:9 clippy::map_unwrap_or "called `map().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` instead" +regex/1.3.2/src/re_unicode.rs:1041:9 clippy::map_unwrap_or "called `map().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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` instead of `Option>` 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)" -- cgit 1.4.1-3-g733a5 From 4ec9cb84bb96ff11eba9d0a8961ddfea2fa1ba65 Mon Sep 17 00:00:00 2001 From: Matthias Krüger Date: Wed, 23 Dec 2020 15:31:18 +0100 Subject: 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 db0dd3641f1..96b94c2c652 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 { + fn run_clippy_lints(&self, cargo_clippy_path: &PathBuf) -> Vec { 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 = 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> = read_crates() + let clippy_warnings: Vec = 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 = clippy_lint_results.into_iter().flatten().collect(); - all_warnings.sort(); + let all_msgs: Vec = 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(); } -- cgit 1.4.1-3-g733a5 From e56c9a52532d87a36da32fbde8066ecc34e67cd4 Mon Sep 17 00:00:00 2001 From: Matthias Krüger Date: Wed, 23 Dec 2020 15:59:16 +0100 Subject: 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 96b94c2c652..7607e6b449f 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 = 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::(); + + let mut all_msgs: Vec = 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 52045f05faa..18a0c2120ff 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 -- cgit 1.4.1-3-g733a5 From d257101109e7ed6ca0a561a9e16d51167d2d92d7 Mon Sep 17 00:00:00 2001 From: Matthias Krüger Date: Sun, 27 Dec 2020 15:44:45 +0100 Subject: 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 7607e6b449f..b0e7cb70c89 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 18a0c2120ff..70b9baf0396 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 -- cgit 1.4.1-3-g733a5 From b6ef1e282ef4c444ce7e5694547aaff4d55c5059 Mon Sep 17 00:00:00 2001 From: Matthias Krüger Date: Sun, 27 Dec 2020 16:13:42 +0100 Subject: 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 b0e7cb70c89..ee4ed451ed5 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 = 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 = 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 6fb8b6f2899..c4688ba3000 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") -- cgit 1.4.1-3-g733a5 From ec1902ce4303632bbb155ade52877c072ff52348 Mon Sep 17 00:00:00 2001 From: Matthias Krüger Date: Sun, 27 Dec 2020 16:20:32 +0100 Subject: 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 d6663145142..0333a260db1 100644 --- a/clippy_dev/Cargo.toml +++ b/clippy_dev/Cargo.toml @@ -4,20 +4,22 @@ version = "0.0.1" authors = ["Philipp Hansch "] 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 ee4ed451ed5..61ada2c2f23 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 = 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 c4688ba3000..e10c3dbe0bd 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() } -- cgit 1.4.1-3-g733a5 From 94a73d7b11d849441cd38b015393c1544422468b Mon Sep 17 00:00:00 2001 From: Matthias Krüger Date: Sun, 27 Dec 2020 16:56:05 +0100 Subject: 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 e70da43ab47..220e74f5df4 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"] -- cgit 1.4.1-3-g733a5 From 48fc948ca3548d5bdcc479b5f9c317767d941e3b Mon Sep 17 00:00:00 2001 From: Matthias Krüger Date: Tue, 29 Dec 2020 16:18:31 +0100 Subject: 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 0333a260db1..4268ef80282 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 61ada2c2f23..98a4af3591e 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 e10c3dbe0bd..c47aabc2e0a 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 70b9baf0396..f9084dc8321 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 -- cgit 1.4.1-3-g733a5 From 83fcf95f52c6e4c9dbb840ce9e562f2d5c859cca Mon Sep 17 00:00:00 2001 From: Matthias Krüger Date: Sat, 23 Jan 2021 00:25:29 +0100 Subject: rename cargo dev crater to cargo dev lintcheck --- .cargo/config | 2 +- clippy_dev/Cargo.toml | 2 +- clippy_dev/crater_crates.toml | 20 - clippy_dev/lintcheck_crates.toml | 20 + clippy_dev/src/crater.rs | 286 ---- clippy_dev/src/lib.rs | 2 +- clippy_dev/src/lintcheck.rs | 286 ++++ clippy_dev/src/main.rs | 18 +- lintcheck-logs/logs.txt | 3367 ++++++++++++++++++++++++++++++++++++++ mini-crater/logs.txt | 3367 -------------------------------------- 10 files changed, 3685 insertions(+), 3685 deletions(-) delete mode 100644 clippy_dev/crater_crates.toml create mode 100644 clippy_dev/lintcheck_crates.toml delete mode 100644 clippy_dev/src/crater.rs create mode 100644 clippy_dev/src/lintcheck.rs create mode 100644 lintcheck-logs/logs.txt delete mode 100644 mini-crater/logs.txt diff --git a/.cargo/config b/.cargo/config index 220e74f5df4..1142cc470fe 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 4268ef80282..f48c1ee5ea2 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/crater_crates.toml deleted file mode 100644 index 1fbf7930d3e..00000000000 --- a/clippy_dev/crater_crates.toml +++ /dev/null @@ -1,20 +0,0 @@ -[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/lintcheck_crates.toml b/clippy_dev/lintcheck_crates.toml new file mode 100644 index 00000000000..1fbf7930d3e --- /dev/null +++ b/clippy_dev/lintcheck_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 deleted file mode 100644 index 98a4af3591e..00000000000 --- a/clippy_dev/src/crater.rs +++ /dev/null @@ -1,286 +0,0 @@ -// 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. - -#![cfg(feature = "crater")] -#![allow(clippy::filter_map)] - -use crate::clippy_project_root; - -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; - -// use this to store the crates when interacting with the crates.toml file -#[derive(Debug, Serialize, Deserialize)] -struct CrateList { - crates: HashMap>, -} - -// 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, -} - -// represents an archive we download from crates.io -#[derive(Debug, Serialize, Deserialize, Eq, Hash, PartialEq)] -struct CrateSource { - name: String, - version: String, -} - -// represents the extracted sourcecode of a crate -#[derive(Debug)] -struct Crate { - version: String, - name: String, - // path to the extracted sources that clippy can check - 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"); - 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 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_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 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 - Crate { - version: self.version.clone(), - name: self.name.clone(), - path: extract_dir.join(format!("{}-{}/", self.name, self.version)), - } - } -} - -impl Crate { - fn run_clippy_lints(&self, cargo_clippy_path: &PathBuf) -> Vec { - 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(&[ - "--", - "--message-format=json", - "--", - "--cap-lints=warn", - "-Wclippy::pedantic", - "-Wclippy::cargo", - ]) - .current_dir(&self.path) - .output() - .unwrap(); - let stdout = String::from_utf8_lossy(&all_output.stdout); - let output_lines = stdout.lines(); - //dbg!(&output_lines); - let warnings: Vec = output_lines - .into_iter() - // get all clippy warnings - .filter(|line| line.contains("clippy::")) - .map(|json_msg| parse_json_message(json_msg, &self)) - .collect(); - warnings - } -} - -fn build_clippy() { - Command::new("cargo") - .arg("build") - .output() - .expect("Failed to build clippy!"); -} - -// get a list of CrateSources we want to check from a "crater_crates.toml" file. -fn read_crates() -> Vec { - 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 tomlcrates: Vec = crate_list - .crates - .into_iter() - .map(|(name, versions)| TomlCrate { name, versions }) - .collect(); - - // 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| { - crate_sources.push(CrateSource { - name: tk.name.clone(), - version: ver.to_string(), - }); - }) - }); - 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(clap_config: &ArgMatches) { - let cargo_clippy_path: PathBuf = PathBuf::from("target/debug/cargo-clippy"); - - 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! {}", - 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 - - let crates = read_crates(); - - let clippy_warnings: Vec = if let Some(only_one_crate) = clap_config.value_of("only") { - // 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) - .map(|krate| krate.run_clippy_lints(&cargo_clippy_path)) - .flatten() - .collect() - } else { - // check all crates (default) - crates - .into_iter() - .map(|krate| krate.download_and_extract()) - .map(|krate| krate.run_clippy_lints(&cargo_clippy_path)) - .flatten() - .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 "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() - .map(|(lint, count)| format!("{} {}\n", lint, count)) - .collect::(); - - let mut all_msgs: Vec = 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 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/lib.rs b/clippy_dev/src/lib.rs index 4873769b367..24d70d433f3 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/lintcheck.rs b/clippy_dev/src/lintcheck.rs new file mode 100644 index 00000000000..e2099ff98c8 --- /dev/null +++ b/clippy_dev/src/lintcheck.rs @@ -0,0 +1,286 @@ +// 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. + +#![cfg(feature = "lintcheck")] +#![allow(clippy::filter_map)] + +use crate::clippy_project_root; + +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; + +// use this to store the crates when interacting with the crates.toml file +#[derive(Debug, Serialize, Deserialize)] +struct CrateList { + crates: HashMap>, +} + +// 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, +} + +// represents an archive we download from crates.io +#[derive(Debug, Serialize, Deserialize, Eq, Hash, PartialEq)] +struct CrateSource { + name: String, + version: String, +} + +// represents the extracted sourcecode of a crate +#[derive(Debug)] +struct Crate { + version: String, + name: String, + // path to the extracted sources that clippy can check + 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/lintcheck/crates"); + let krate_download_dir = PathBuf::from("target/lintcheck/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 and extracting {} {} from {}", self.name, self.version, url); + let _ = std::fs::create_dir("target/lintcheck/"); + let _ = std::fs::create_dir(&krate_download_dir); + let _ = std::fs::create_dir(&extract_dir); + + 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 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 + Crate { + version: self.version.clone(), + name: self.name.clone(), + path: extract_dir.join(format!("{}-{}/", self.name, self.version)), + } + } +} + +impl Crate { + fn run_clippy_lints(&self, cargo_clippy_path: &PathBuf) -> Vec { + 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/lintcheck/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(&[ + "--", + "--message-format=json", + "--", + "--cap-lints=warn", + "-Wclippy::pedantic", + "-Wclippy::cargo", + ]) + .current_dir(&self.path) + .output() + .unwrap(); + let stdout = String::from_utf8_lossy(&all_output.stdout); + let output_lines = stdout.lines(); + //dbg!(&output_lines); + let warnings: Vec = output_lines + .into_iter() + // get all clippy warnings + .filter(|line| line.contains("clippy::")) + .map(|json_msg| parse_json_message(json_msg, &self)) + .collect(); + warnings + } +} + +fn build_clippy() { + Command::new("cargo") + .arg("build") + .output() + .expect("Failed to build clippy!"); +} + +// get a list of CrateSources we want to check from a "lintcheck_crates.toml" file. +fn read_crates() -> Vec { + 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 = + 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 tomlcrates: Vec = crate_list + .crates + .into_iter() + .map(|(name, versions)| TomlCrate { name, versions }) + .collect(); + + // 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| { + crate_sources.push(CrateSource { + name: tk.name.clone(), + version: ver.to_string(), + }); + }) + }); + 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(clap_config: &ArgMatches) { + let cargo_clippy_path: PathBuf = PathBuf::from("target/debug/cargo-clippy"); + + 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! {}", + 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 + + let crates = read_crates(); + + let clippy_warnings: Vec = if let Some(only_one_crate) = clap_config.value_of("only") { + // 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/lintcheck_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) + .map(|krate| krate.run_clippy_lints(&cargo_clippy_path)) + .flatten() + .collect() + } else { + // check all crates (default) + crates + .into_iter() + .map(|krate| krate.download_and_extract()) + .map(|krate| krate.run_clippy_lints(&cargo_clippy_path)) + .flatten() + .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 "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() + .map(|(lint, count)| format!("{} {}\n", lint, count)) + .collect::(); + + let mut all_msgs: Vec = 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 lintcheck-logs/logs.txt + let mut text = clippy_ver; // clippy version number on top + text.push_str(&format!("\n{}", all_msgs.join(""))); + write("lintcheck-logs/logs.txt", text).unwrap(); +} diff --git a/clippy_dev/src/main.rs b/clippy_dev/src/main.rs index c47aabc2e0a..e7a298a37e1 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/lintcheck-logs/logs.txt b/lintcheck-logs/logs.txt new file mode 100644 index 00000000000..f9084dc8321 --- /dev/null +++ b/lintcheck-logs/logs.txt @@ -0,0 +1,3367 @@ +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" +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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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/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: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: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: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` instead of `Option>` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` instead" +regex/1.3.2/src/expand.rs:42:21 clippy::map_unwrap_or "called `map().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` instead" +regex/1.3.2/src/expand.rs:84:21 clippy::map_unwrap_or "called `map().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` instead" +regex/1.3.2/src/re_bytes.rs:1039:9 clippy::map_unwrap_or "called `map().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` instead" +regex/1.3.2/src/re_unicode.rs:1041:9 clippy::map_unwrap_or "called `map().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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 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 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` instead of `Option>` 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)" + + + + +Stats + +clippy::clone_on_copy 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::precedence 1 +clippy::pub_enum_variant_names 1 +clippy::redundant_clone 1 +clippy::same_item_push 1 +clippy::should_implement_trait 1 +clippy::stable_sort_primitive 1 +clippy::unit_arg 1 +clippy::unnecessary_lazy_evaluations 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::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::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 diff --git a/mini-crater/logs.txt b/mini-crater/logs.txt deleted file mode 100644 index f9084dc8321..00000000000 --- a/mini-crater/logs.txt +++ /dev/null @@ -1,3367 +0,0 @@ -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" -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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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/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: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: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: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` instead of `Option>` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` instead" -regex/1.3.2/src/expand.rs:42:21 clippy::map_unwrap_or "called `map().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` instead" -regex/1.3.2/src/expand.rs:84:21 clippy::map_unwrap_or "called `map().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` instead" -regex/1.3.2/src/re_bytes.rs:1039:9 clippy::map_unwrap_or "called `map().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` instead" -regex/1.3.2/src/re_unicode.rs:1041:9 clippy::map_unwrap_or "called `map().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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 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 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` instead of `Option>` 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)" - - - - -Stats - -clippy::clone_on_copy 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::precedence 1 -clippy::pub_enum_variant_names 1 -clippy::redundant_clone 1 -clippy::same_item_push 1 -clippy::should_implement_trait 1 -clippy::stable_sort_primitive 1 -clippy::unit_arg 1 -clippy::unnecessary_lazy_evaluations 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::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::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 -- cgit 1.4.1-3-g733a5 From d0d28b11d7d9948747404ca0cb0a06280e1c15fb Mon Sep 17 00:00:00 2001 From: Matthias Krüger Date: Sat, 23 Jan 2021 01:08:48 +0100 Subject: 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 f9084dc8321..f61e9b38775 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` instead" regex/1.3.2/src/expand.rs:42:21 clippy::map_unwrap_or "called `map().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` instead" regex/1.3.2/src/expand.rs:84:21 clippy::map_unwrap_or "called `map().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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 -- cgit 1.4.1-3-g733a5 From 5b6a18362be15a693e202a592f4ae6bc4b2844f2 Mon Sep 17 00:00:00 2001 From: Matthias Krüger Date: Sat, 23 Jan 2021 01:09:51 +0100 Subject: 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 e2099ff98c8..785c692d3cb 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 f61e9b38775..e565691e0e3 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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` instead of `Option>` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` instead" -regex/1.3.2/src/expand.rs:42:21 clippy::map_unwrap_or "called `map().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` instead" -regex/1.3.2/src/expand.rs:84:21 clippy::map_unwrap_or "called `map().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` instead" -regex/1.3.2/src/re_bytes.rs:1039:9 clippy::map_unwrap_or "called `map().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` instead" -regex/1.3.2/src/re_unicode.rs:1041:9 clippy::map_unwrap_or "called `map().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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` instead of `Option>` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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` instead of `Option>` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` instead" +regex-1.3.2/src/expand.rs:42:21 clippy::map_unwrap_or "called `map().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` instead" +regex-1.3.2/src/expand.rs:84:21 clippy::map_unwrap_or "called `map().unwrap_or()` on an `Option` value. This can be done more directly by calling `map_or(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` instead" +regex-1.3.2/src/re_bytes.rs:1039:9 clippy::map_unwrap_or "called `map().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` instead" +regex-1.3.2/src/re_unicode.rs:1041:9 clippy::map_unwrap_or "called `map().unwrap_or_else()` on an `Option` value. This can be done more directly by calling `map_or_else(, )` 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` instead of `Option>` 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)" -- cgit 1.4.1-3-g733a5 From 0373dc3ade666c4fb06ab9cca5fa840d4988a9c3 Mon Sep 17 00:00:00 2001 From: xFrednet Date: Fri, 22 Jan 2021 19:04:28 +0100 Subject: 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 1a7a30c61be..fd2a7d171d0 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. + (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 8f2a20bfe24..57f83bdf32b 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 . | 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 -- cgit 1.4.1-3-g733a5 From e0ae980fab38e61bf39380e69bbf0000e681a9f8 Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Mon, 25 Jan 2021 14:35:57 -0800 Subject: 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 4749e36238c..32b1299efce 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]", - ); - } } } } -- cgit 1.4.1-3-g733a5 From 3e3dff71357005556aba8d9a7893829f7510b079 Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Mon, 25 Jan 2021 14:39:03 -0800 Subject: 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 7e355d2a58b..8174a0175ab 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 ed86b50be30..b476f09f8a0 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 a24e64b6705..7369fe75a4f 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 -- cgit 1.4.1-3-g733a5 From cbf9d492b9a60c7267907731941d14ec96510681 Mon Sep 17 00:00:00 2001 From: Cameron Steffen Date: Tue, 26 Jan 2021 17:38:37 -0600 Subject: 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 5d1bd60acf3..1248e6b6a26 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) -- cgit 1.4.1-3-g733a5 From 60ab57e4eb0bc8845e0a5a683e10d2e39147094a Mon Sep 17 00:00:00 2001 From: flip1995 Date: Sat, 30 Jan 2021 15:52:02 +0100 Subject: 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 72935072f8c..f55d55d7065 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"] -- cgit 1.4.1-3-g733a5 From 797cf6554dd48792ed22c4f81322979548d542d1 Mon Sep 17 00:00:00 2001 From: flip1995 Date: Sat, 30 Jan 2021 17:43:00 +0100 Subject: Get rid of regex and lazy_static dependencies --- clippy_lints/Cargo.toml | 2 -- clippy_lints/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 38098f8a14c..a9516560a61 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 d5347ce6ed7..6969ac949d8 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 { - 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() { -- cgit 1.4.1-3-g733a5 From 3874631600811d964f18784859b34302d5533358 Mon Sep 17 00:00:00 2001 From: flip1995 Date: Sat, 30 Jan 2021 17:43:20 +0100 Subject: 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 a7a6b5855b7..6caa04f651f 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, -- cgit 1.4.1-3-g733a5