From f49ef0ec040869843170ca132100bb8eee2071e6 Mon Sep 17 00:00:00 2001 From: Oliver Scherer Date: Sat, 18 May 2019 01:34:52 +0200 Subject: [PATCH] Dogfood --- clippy_lints/src/approx_const.rs | 2 +- clippy_lints/src/infinite_iter.rs | 6 +- clippy_lints/src/methods/mod.rs | 117 +++++++++++------------ clippy_lints/src/replace_consts.rs | 2 +- clippy_lints/src/utils/internal_lints.rs | 17 ++-- clippy_lints/src/utils/paths.rs | 4 +- 6 files changed, 73 insertions(+), 75 deletions(-) diff --git a/clippy_lints/src/approx_const.rs b/clippy_lints/src/approx_const.rs index 873df03ceb0..15de7821144 100644 --- a/clippy_lints/src/approx_const.rs +++ b/clippy_lints/src/approx_const.rs @@ -72,7 +72,7 @@ fn check_lit(cx: &LateContext<'_, '_>, lit: &LitKind, e: &Expr) { fn check_known_consts(cx: &LateContext<'_, '_>, e: &Expr, s: symbol::Symbol, module: &str) { let s = s.as_str(); if s.parse::().is_ok() { - for &(constant, name, min_digits) in KNOWN_CONSTS.iter() { + for &(constant, name, min_digits) in &KNOWN_CONSTS { if is_approx_const(constant, &s, min_digits) { span_lint( cx, diff --git a/clippy_lints/src/infinite_iter.rs b/clippy_lints/src/infinite_iter.rs index 46faa87d6a9..92768d14fd4 100644 --- a/clippy_lints/src/infinite_iter.rs +++ b/clippy_lints/src/infinite_iter.rs @@ -139,7 +139,7 @@ const HEURISTICS: [(&str, usize, Heuristic, Finiteness); 19] = [ fn is_infinite(cx: &LateContext<'_, '_>, expr: &Expr) -> Finiteness { match expr.node { ExprKind::MethodCall(ref method, _, ref args) => { - for &(name, len, heuristic, cap) in HEURISTICS.iter() { + for &(name, len, heuristic, cap) in &HEURISTICS { if method.ident.name.as_str() == name && args.len() == len { return (match heuristic { Always => Infinite, @@ -215,12 +215,12 @@ const INFINITE_COLLECTORS: [&[&str]; 8] = [ fn complete_infinite_iter(cx: &LateContext<'_, '_>, expr: &Expr) -> Finiteness { match expr.node { ExprKind::MethodCall(ref method, _, ref args) => { - for &(name, len) in COMPLETING_METHODS.iter() { + for &(name, len) in &COMPLETING_METHODS { if method.ident.name.as_str() == name && args.len() == len { return is_infinite(cx, &args[0]); } } - for &(name, len) in POSSIBLY_COMPLETING_METHODS.iter() { + for &(name, len) in &POSSIBLY_COMPLETING_METHODS { if method.ident.name.as_str() == name && args.len() == len { return MaybeInfinite.and(is_infinite(cx, &args[0])); } diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs index 44cc537844a..de7d5a46453 100644 --- a/clippy_lints/src/methods/mod.rs +++ b/clippy_lints/src/methods/mod.rs @@ -6,7 +6,6 @@ use std::fmt; use std::iter; use if_chain::if_chain; -use lazy_static::lazy_static; use matches::matches; use rustc::hir; use rustc::hir::def::{DefKind, Res}; @@ -17,7 +16,7 @@ use rustc::{declare_lint_pass, declare_tool_lint}; use rustc_errors::Applicability; use syntax::ast; use syntax::source_map::{BytePos, Span}; -use syntax::symbol::{LocalInternedString, Symbol}; +use syntax::symbol::LocalInternedString; use crate::utils::paths; use crate::utils::sugg; @@ -914,8 +913,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Methods { match self_ty.sty { ty::Ref(_, ty, _) if ty.sty == ty::Str => { - for &(method, pos) in PATTERN_METHODS.iter() { - if method_call.ident.name == method && args.len() > pos { + for &(method, pos) in &PATTERN_METHODS { + if method_call.ident.name.as_str() == method && args.len() > pos { lint_single_char_pattern(cx, expr, &args[pos]); } } @@ -945,7 +944,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Methods { if in_external_macro(cx.sess(), implitem.span) { return; } - let name = implitem.ident.name; + let name = implitem.ident.name.as_str(); let parent = cx.tcx.hir().get_parent_item(implitem.hir_id); let item = cx.tcx.hir().expect_item_by_hir_id(parent); let def_id = cx.tcx.hir().local_def_id_from_hir_id(item.hir_id); @@ -958,7 +957,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Methods { then { if cx.access_levels.is_exported(implitem.hir_id) { // check missing trait implementations - for &(method_name, n_args, self_kind, out_type, trait_name) in TRAIT_METHODS.iter() { + for &(method_name, n_args, self_kind, out_type, trait_name) in &TRAIT_METHODS { if name == method_name && sig.decl.inputs.len() == n_args && out_type.matches(cx, &sig.decl.output) && @@ -973,7 +972,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Methods { // check conventions w.r.t. conversion method names and predicates let is_copy = is_copy(cx, ty); for &(ref conv, self_kinds) in &CONVENTIONS { - if conv.check(&name.as_str()) { + if conv.check(&name) { if !self_kinds .iter() .any(|k| k.matches(cx, first_arg_ty, first_arg, self_ty, is_copy, &implitem.generics)) { @@ -1032,7 +1031,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Methods { } } - if name == sym!(new) && !same_tys(cx, ret_ty, ty) { + if name == "new" && !same_tys(cx, ret_ty, ty) { span_lint( cx, NEW_RET_NO_SELF, @@ -2407,63 +2406,59 @@ const CONVENTIONS: [(Convention, &[SelfKind]); 7] = [ ]; #[rustfmt::skip] -lazy_static! { -static ref TRAIT_METHODS: [(Symbol, usize, SelfKind, OutType, &'static str); 30] = [ - (sym!(add), 2, SelfKind::Value, OutType::Any, "std::ops::Add"), - (sym!(as_mut), 1, SelfKind::RefMut, OutType::Ref, "std::convert::AsMut"), - (sym!(as_ref), 1, SelfKind::Ref, OutType::Ref, "std::convert::AsRef"), - (sym!(bitand), 2, SelfKind::Value, OutType::Any, "std::ops::BitAnd"), - (sym!(bitor), 2, SelfKind::Value, OutType::Any, "std::ops::BitOr"), - (sym!(bitxor), 2, SelfKind::Value, OutType::Any, "std::ops::BitXor"), - (sym!(borrow), 1, SelfKind::Ref, OutType::Ref, "std::borrow::Borrow"), - (sym!(borrow_mut), 1, SelfKind::RefMut, OutType::Ref, "std::borrow::BorrowMut"), - (sym!(clone), 1, SelfKind::Ref, OutType::Any, "std::clone::Clone"), - (sym!(cmp), 2, SelfKind::Ref, OutType::Any, "std::cmp::Ord"), - (sym!(default), 0, SelfKind::No, OutType::Any, "std::default::Default"), - (sym!(deref), 1, SelfKind::Ref, OutType::Ref, "std::ops::Deref"), - (sym!(deref_mut), 1, SelfKind::RefMut, OutType::Ref, "std::ops::DerefMut"), - (sym!(div), 2, SelfKind::Value, OutType::Any, "std::ops::Div"), - (sym!(drop), 1, SelfKind::RefMut, OutType::Unit, "std::ops::Drop"), - (sym!(eq), 2, SelfKind::Ref, OutType::Bool, "std::cmp::PartialEq"), - (sym!(from_iter), 1, SelfKind::No, OutType::Any, "std::iter::FromIterator"), - (sym!(from_str), 1, SelfKind::No, OutType::Any, "std::str::FromStr"), - (sym!(hash), 2, SelfKind::Ref, OutType::Unit, "std::hash::Hash"), - (sym!(index), 2, SelfKind::Ref, OutType::Ref, "std::ops::Index"), - (sym!(index_mut), 2, SelfKind::RefMut, OutType::Ref, "std::ops::IndexMut"), - (sym!(into_iter), 1, SelfKind::Value, OutType::Any, "std::iter::IntoIterator"), - (sym!(mul), 2, SelfKind::Value, OutType::Any, "std::ops::Mul"), - (sym!(neg), 1, SelfKind::Value, OutType::Any, "std::ops::Neg"), - (sym!(next), 1, SelfKind::RefMut, OutType::Any, "std::iter::Iterator"), - (sym!(not), 1, SelfKind::Value, OutType::Any, "std::ops::Not"), - (sym!(rem), 2, SelfKind::Value, OutType::Any, "std::ops::Rem"), - (sym!(shl), 2, SelfKind::Value, OutType::Any, "std::ops::Shl"), - (sym!(shr), 2, SelfKind::Value, OutType::Any, "std::ops::Shr"), - (sym!(sub), 2, SelfKind::Value, OutType::Any, "std::ops::Sub"), +const TRAIT_METHODS: [(&str, usize, SelfKind, OutType, &str); 30] = [ + ("add", 2, SelfKind::Value, OutType::Any, "std::ops::Add"), + ("as_mut", 1, SelfKind::RefMut, OutType::Ref, "std::convert::AsMut"), + ("as_ref", 1, SelfKind::Ref, OutType::Ref, "std::convert::AsRef"), + ("bitand", 2, SelfKind::Value, OutType::Any, "std::ops::BitAnd"), + ("bitor", 2, SelfKind::Value, OutType::Any, "std::ops::BitOr"), + ("bitxor", 2, SelfKind::Value, OutType::Any, "std::ops::BitXor"), + ("borrow", 1, SelfKind::Ref, OutType::Ref, "std::borrow::Borrow"), + ("borrow_mut", 1, SelfKind::RefMut, OutType::Ref, "std::borrow::BorrowMut"), + ("clone", 1, SelfKind::Ref, OutType::Any, "std::clone::Clone"), + ("cmp", 2, SelfKind::Ref, OutType::Any, "std::cmp::Ord"), + ("default", 0, SelfKind::No, OutType::Any, "std::default::Default"), + ("deref", 1, SelfKind::Ref, OutType::Ref, "std::ops::Deref"), + ("deref_mut", 1, SelfKind::RefMut, OutType::Ref, "std::ops::DerefMut"), + ("div", 2, SelfKind::Value, OutType::Any, "std::ops::Div"), + ("drop", 1, SelfKind::RefMut, OutType::Unit, "std::ops::Drop"), + ("eq", 2, SelfKind::Ref, OutType::Bool, "std::cmp::PartialEq"), + ("from_iter", 1, SelfKind::No, OutType::Any, "std::iter::FromIterator"), + ("from_str", 1, SelfKind::No, OutType::Any, "std::str::FromStr"), + ("hash", 2, SelfKind::Ref, OutType::Unit, "std::hash::Hash"), + ("index", 2, SelfKind::Ref, OutType::Ref, "std::ops::Index"), + ("index_mut", 2, SelfKind::RefMut, OutType::Ref, "std::ops::IndexMut"), + ("into_iter", 1, SelfKind::Value, OutType::Any, "std::iter::IntoIterator"), + ("mul", 2, SelfKind::Value, OutType::Any, "std::ops::Mul"), + ("neg", 1, SelfKind::Value, OutType::Any, "std::ops::Neg"), + ("next", 1, SelfKind::RefMut, OutType::Any, "std::iter::Iterator"), + ("not", 1, SelfKind::Value, OutType::Any, "std::ops::Not"), + ("rem", 2, SelfKind::Value, OutType::Any, "std::ops::Rem"), + ("shl", 2, SelfKind::Value, OutType::Any, "std::ops::Shl"), + ("shr", 2, SelfKind::Value, OutType::Any, "std::ops::Shr"), + ("sub", 2, SelfKind::Value, OutType::Any, "std::ops::Sub"), ]; -} #[rustfmt::skip] -lazy_static! { -static ref PATTERN_METHODS: [(Symbol, usize); 17] = [ - (sym!(contains), 1), - (sym!(starts_with), 1), - (sym!(ends_with), 1), - (sym!(find), 1), - (sym!(rfind), 1), - (sym!(split), 1), - (sym!(rsplit), 1), - (sym!(split_terminator), 1), - (sym!(rsplit_terminator), 1), - (sym!(splitn), 2), - (sym!(rsplitn), 2), - (sym!(matches), 1), - (sym!(rmatches), 1), - (sym!(match_indices), 1), - (sym!(rmatch_indices), 1), - (sym!(trim_start_matches), 1), - (sym!(trim_end_matches), 1), +const PATTERN_METHODS: [(&str, usize); 17] = [ + ("contains", 1), + ("starts_with", 1), + ("ends_with", 1), + ("find", 1), + ("rfind", 1), + ("split", 1), + ("rsplit", 1), + ("split_terminator", 1), + ("rsplit_terminator", 1), + ("splitn", 2), + ("rsplitn", 2), + ("matches", 1), + ("rmatches", 1), + ("match_indices", 1), + ("rmatch_indices", 1), + ("trim_start_matches", 1), + ("trim_end_matches", 1), ]; -} #[derive(Clone, Copy, PartialEq, Debug)] enum SelfKind { diff --git a/clippy_lints/src/replace_consts.rs b/clippy_lints/src/replace_consts.rs index 81d7f7d58e7..c15eca15c1b 100644 --- a/clippy_lints/src/replace_consts.rs +++ b/clippy_lints/src/replace_consts.rs @@ -37,7 +37,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ReplaceConsts { if let hir::ExprKind::Path(ref qp) = expr.node; if let Res::Def(DefKind::Const, def_id) = cx.tables.qpath_res(qp, expr.hir_id); then { - for (const_path, repl_snip) in REPLACEMENTS.iter() { + for (const_path, repl_snip) in &REPLACEMENTS { if match_def_path(cx, def_id, const_path) { span_lint_and_sugg( cx, diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs index b64f6b0dfc1..5e79c231e41 100644 --- a/clippy_lints/src/utils/internal_lints.rs +++ b/clippy_lints/src/utils/internal_lints.rs @@ -7,8 +7,9 @@ use rustc::hir::*; use rustc::lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintArray, LintPass}; use rustc::{declare_lint_pass, declare_tool_lint, impl_lint_pass}; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; -use syntax::ast::{Crate as AstCrate, Name}; +use syntax::ast::{Crate as AstCrate, ItemKind, Name}; use syntax::source_map::Span; +use syntax_pos::symbol::LocalInternedString; declare_clippy_lint! { /// **What it does:** Checks for various things we like to keep tidy in clippy. @@ -74,12 +75,15 @@ declare_clippy_lint! { declare_lint_pass!(ClippyLintsInternal => [CLIPPY_LINTS_INTERNAL]); impl EarlyLintPass for ClippyLintsInternal { - fn check_crate(&mut self, _cx: &EarlyContext<'_>, _krate: &AstCrate) { - /* - FIXME: turn back on when we get rid of all the lazy_statics - if let Some(utils) = krate.module.items.iter().find(|item| item.ident.name == sym!(utils)) { + fn check_crate(&mut self, cx: &EarlyContext<'_>, krate: &AstCrate) { + if let Some(utils) = krate + .module + .items + .iter() + .find(|item| item.ident.name.as_str() == "utils") + { if let ItemKind::Mod(ref utils_mod) = utils.node { - if let Some(paths) = utils_mod.items.iter().find(|item| item.ident.name == sym!(paths)) { + if let Some(paths) = utils_mod.items.iter().find(|item| item.ident.name.as_str() == "paths") { if let ItemKind::Mod(ref paths_mod) = paths.node { let mut last_name: Option = None; for item in &*paths_mod.items { @@ -101,7 +105,6 @@ impl EarlyLintPass for ClippyLintsInternal { } } } - */ } } diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs index 4c693d2d0d4..e0f4d408008 100644 --- a/clippy_lints/src/utils/paths.rs +++ b/clippy_lints/src/utils/paths.rs @@ -96,10 +96,10 @@ pub const RESULT_OK: [&str; 4] = ["core", "result", "Result", "Ok"]; pub const SERDE_DE_VISITOR: [&str; 3] = ["serde", "de", "Visitor"]; pub const SLICE_INTO_VEC: [&str; 4] = ["alloc", "slice", "", "into_vec"]; pub const SLICE_ITER: [&str; 3] = ["core", "slice", "Iter"]; -pub const STD_MEM_TRANSMUTE: [&str; 3] = ["std", "mem", "transmute"]; -pub const STD_PTR_NULL: [&str; 3] = ["std", "ptr", "null"]; pub const STDERR: [&str; 4] = ["std", "io", "stdio", "stderr"]; pub const STDOUT: [&str; 4] = ["std", "io", "stdio", "stdout"]; +pub const STD_MEM_TRANSMUTE: [&str; 3] = ["std", "mem", "transmute"]; +pub const STD_PTR_NULL: [&str; 3] = ["std", "ptr", "null"]; pub const STRING: [&str; 3] = ["alloc", "string", "String"]; pub const TO_OWNED: [&str; 3] = ["alloc", "borrow", "ToOwned"]; pub const TO_OWNED_METHOD: [&str; 4] = ["alloc", "borrow", "ToOwned", "to_owned"];