From 9afd8abbe345095ee8755e2872a33cc7666e7790 Mon Sep 17 00:00:00 2001 From: Devon Hollowood Date: Thu, 11 Oct 2018 15:18:58 -0700 Subject: [PATCH 1/4] Fix `similar_names` warnings Most of these are just `#![allow]`ed, because they are things like using l vs r to differentiate left vs right. These would be made less clear by taking the advice of `similar_names` --- clippy_lints/src/double_comparison.rs | 1 + clippy_lints/src/enum_clike.rs | 12 ++++++------ clippy_lints/src/enum_variants.rs | 1 + clippy_lints/src/eq_op.rs | 1 + .../src/if_let_redundant_pattern_matching.rs | 1 + clippy_lints/src/transmute.rs | 1 + clippy_lints/src/utils/hir_utils.rs | 3 +++ clippy_lints/src/utils/inspector.rs | 2 ++ clippy_lints/src/utils/usage.rs | 1 + 9 files changed, 17 insertions(+), 6 deletions(-) diff --git a/clippy_lints/src/double_comparison.rs b/clippy_lints/src/double_comparison.rs index e151918c1fb4..3710301c8ab6 100644 --- a/clippy_lints/src/double_comparison.rs +++ b/clippy_lints/src/double_comparison.rs @@ -49,6 +49,7 @@ impl LintPass for DoubleComparisonPass { } impl<'a, 'tcx> DoubleComparisonPass { + #[allow(clippy::similar_names)] fn check_binop( &self, cx: &LateContext<'a, 'tcx>, diff --git a/clippy_lints/src/enum_clike.rs b/clippy_lints/src/enum_clike.rs index 313175aee849..315bc54cd179 100644 --- a/clippy_lints/src/enum_clike.rs +++ b/clippy_lints/src/enum_clike.rs @@ -63,16 +63,16 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnportableVariant { let variant = &var.node; if let Some(ref anon_const) = variant.disr_expr { let param_env = ty::ParamEnv::empty(); - let did = cx.tcx.hir.body_owner_def_id(anon_const.body); - let substs = Substs::identity_for_item(cx.tcx.global_tcx(), did); - let instance = ty::Instance::new(did, substs); - let cid = GlobalId { + let def_id = cx.tcx.hir.body_owner_def_id(anon_const.body); + let substs = Substs::identity_for_item(cx.tcx.global_tcx(), def_id); + let instance = ty::Instance::new(def_id, substs); + let c_id = GlobalId { instance, promoted: None }; - let constant = cx.tcx.const_eval(param_env.and(cid)).ok(); + let constant = cx.tcx.const_eval(param_env.and(c_id)).ok(); if let Some(Constant::Int(val)) = constant.and_then(|c| miri_to_const(cx.tcx, c)) { - let mut ty = cx.tcx.type_of(did); + let mut ty = cx.tcx.type_of(def_id); if let ty::Adt(adt, _) = ty.sty { if adt.is_enum() { ty = adt.repr.discr_type().to_ty(cx.tcx); diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs index 8d708f017203..3454eff08a90 100644 --- a/clippy_lints/src/enum_variants.rs +++ b/clippy_lints/src/enum_variants.rs @@ -255,6 +255,7 @@ impl EarlyLintPass for EnumVariantNames { assert!(last.is_some()); } + #[allow(clippy::similar_names)] fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) { let item_name = item.ident.as_str(); let item_name_chars = item_name.chars().count(); diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs index a454ea836950..dfe0c0180a77 100644 --- a/clippy_lints/src/eq_op.rs +++ b/clippy_lints/src/eq_op.rs @@ -63,6 +63,7 @@ impl LintPass for EqOp { } impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EqOp { + #[allow(clippy::similar_names)] fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { if let ExprKind::Binary(op, ref left, ref right) = e.node { if in_macro(e.span) { diff --git a/clippy_lints/src/if_let_redundant_pattern_matching.rs b/clippy_lints/src/if_let_redundant_pattern_matching.rs index 8b42eaa528e7..bced0c9552d0 100644 --- a/clippy_lints/src/if_let_redundant_pattern_matching.rs +++ b/clippy_lints/src/if_let_redundant_pattern_matching.rs @@ -56,6 +56,7 @@ impl LintPass for Pass { } impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { + #[allow(clippy::similar_names)] fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if let ExprKind::Match(ref op, ref arms, MatchSource::IfLetDesugar { .. }) = expr.node { if arms[0].pats.len() == 1 { diff --git a/clippy_lints/src/transmute.rs b/clippy_lints/src/transmute.rs index 0d49f5de2652..801b6db63f5e 100644 --- a/clippy_lints/src/transmute.rs +++ b/clippy_lints/src/transmute.rs @@ -227,6 +227,7 @@ impl LintPass for Transmute { } impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Transmute { + #[allow(clippy::similar_names)] fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { if let ExprKind::Call(ref path_expr, ref args) = e.node { if let ExprKind::Path(ref qpath) = path_expr.node { diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs index bc55c22979b5..7a0b28d15d87 100644 --- a/clippy_lints/src/utils/hir_utils.rs +++ b/clippy_lints/src/utils/hir_utils.rs @@ -73,6 +73,7 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { && both(&left.expr, &right.expr, |l, r| self.eq_expr(l, r)) } + #[allow(clippy::similar_names)] pub fn eq_expr(&mut self, left: &Expr, right: &Expr) -> bool { if self.ignore_fn && differing_macro_contexts(left.span, right.span) { return false; @@ -208,6 +209,7 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { } } + #[allow(clippy::similar_names)] fn eq_qpath(&mut self, left: &QPath, right: &QPath) -> bool { match (left, right) { (&QPath::Resolved(ref lty, ref lpath), &QPath::Resolved(ref rty, ref rpath)) => { @@ -262,6 +264,7 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { self.eq_ty_kind(&left.node, &right.node) } + #[allow(clippy::similar_names)] pub fn eq_ty_kind(&mut self, left: &TyKind, right: &TyKind) -> bool { match (left, right) { (&TyKind::Slice(ref l_vec), &TyKind::Slice(ref r_vec)) => self.eq_ty(l_vec, r_vec), diff --git a/clippy_lints/src/utils/inspector.rs b/clippy_lints/src/utils/inspector.rs index 841aaaabdfa7..ea48aa9ab5e7 100644 --- a/clippy_lints/src/utils/inspector.rs +++ b/clippy_lints/src/utils/inspector.rs @@ -166,6 +166,7 @@ fn print_decl(cx: &LateContext<'_, '_>, decl: &hir::Decl) { } } +#[allow(clippy::similar_names)] fn print_expr(cx: &LateContext<'_, '_>, expr: &hir::Expr, indent: usize) { let ind = " ".repeat(indent); println!("{}+", ind); @@ -424,6 +425,7 @@ fn print_item(cx: &LateContext<'_, '_>, item: &hir::Item) { } } +#[allow(clippy::similar_names)] fn print_pat(cx: &LateContext<'_, '_>, pat: &hir::Pat, indent: usize) { let ind = " ".repeat(indent); println!("{}+", ind); diff --git a/clippy_lints/src/utils/usage.rs b/clippy_lints/src/utils/usage.rs index d26ffc715e87..f3af698ffa2f 100644 --- a/clippy_lints/src/utils/usage.rs +++ b/clippy_lints/src/utils/usage.rs @@ -54,6 +54,7 @@ struct MutVarsDelegate { } impl<'tcx> MutVarsDelegate { + #[allow(clippy::similar_names)] fn update(&mut self, cat: &'tcx Categorization<'_>) { match *cat { Categorization::Local(id) => { From dcef9d07952eae2a2fbfe8f01e3885352c4ce8fb Mon Sep 17 00:00:00 2001 From: Devon Hollowood Date: Thu, 11 Oct 2018 15:36:40 -0700 Subject: [PATCH 2/4] Fix `stutter` lints --- clippy_lints/src/double_comparison.rs | 1 + clippy_lints/src/enum_variants.rs | 12 ++++----- clippy_lints/src/question_mark.rs | 1 + clippy_lints/src/utils/camel_case.rs | 38 +++++++++++++-------------- clippy_lints/src/utils/mod.rs | 3 +-- 5 files changed, 28 insertions(+), 27 deletions(-) diff --git a/clippy_lints/src/double_comparison.rs b/clippy_lints/src/double_comparison.rs index 3710301c8ab6..314ca41ba21c 100644 --- a/clippy_lints/src/double_comparison.rs +++ b/clippy_lints/src/double_comparison.rs @@ -40,6 +40,7 @@ declare_clippy_lint! { "unnecessary double comparisons that can be simplified" } +#[allow(clippy::stutter)] pub struct DoubleComparisonPass; impl LintPass for DoubleComparisonPass { diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs index 3454eff08a90..16d1e40484d0 100644 --- a/clippy_lints/src/enum_variants.rs +++ b/clippy_lints/src/enum_variants.rs @@ -16,7 +16,7 @@ use crate::syntax::ast::*; use crate::syntax::source_map::Span; use crate::syntax::symbol::LocalInternedString; use crate::utils::{span_help_and_lint, span_lint}; -use crate::utils::{camel_case_from, camel_case_until, in_macro}; +use crate::utils::{camel_case, in_macro}; /// **What it does:** Detects enumeration variants that are prefixed or suffixed /// by the same characters. @@ -184,19 +184,19 @@ fn check_variant( } } let first = var2str(&def.variants[0]); - let mut pre = &first[..camel_case_until(&*first)]; - let mut post = &first[camel_case_from(&*first)..]; + let mut pre = &first[..camel_case::until(&*first)]; + let mut post = &first[camel_case::from(&*first)..]; for var in &def.variants { let name = var2str(var); let pre_match = partial_match(pre, &name); pre = &pre[..pre_match]; - let pre_camel = camel_case_until(pre); + let pre_camel = camel_case::until(pre); pre = &pre[..pre_camel]; while let Some((next, last)) = name[pre.len()..].chars().zip(pre.chars().rev()).next() { if next.is_lowercase() { let last = pre.len() - last.len_utf8(); - let last_camel = camel_case_until(&pre[..last]); + let last_camel = camel_case::until(&pre[..last]); pre = &pre[..last_camel]; } else { break; @@ -206,7 +206,7 @@ fn check_variant( let post_match = partial_rmatch(post, &name); let post_end = post.len() - post_match; post = &post[post_end..]; - let post_camel = camel_case_from(post); + let post_camel = camel_case::from(post); post = &post[post_camel..]; } let (what, value) = match (pre.is_empty(), post.is_empty()) { diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs index 0ec57e0be800..93a40e13540f 100644 --- a/clippy_lints/src/question_mark.rs +++ b/clippy_lints/src/question_mark.rs @@ -44,6 +44,7 @@ declare_clippy_lint!{ "checks for expressions that could be replaced by the question mark operator" } +#[allow(clippy::stutter)] #[derive(Copy, Clone)] pub struct QuestionMarkPass; diff --git a/clippy_lints/src/utils/camel_case.rs b/clippy_lints/src/utils/camel_case.rs index 2b60e2c32faa..5ce1e08d8b53 100644 --- a/clippy_lints/src/utils/camel_case.rs +++ b/clippy_lints/src/utils/camel_case.rs @@ -10,7 +10,7 @@ /// Return the index of the character after the first camel-case component of /// `s`. -pub fn camel_case_until(s: &str) -> usize { +pub fn until(s: &str) -> usize { let mut iter = s.char_indices(); if let Some((_, first)) = iter.next() { if !first.is_uppercase() { @@ -43,7 +43,7 @@ pub fn camel_case_until(s: &str) -> usize { } /// Return index of the last camel-case component of `s`. -pub fn camel_case_from(s: &str) -> usize { +pub fn from(s: &str) -> usize { let mut iter = s.char_indices().rev(); if let Some((_, first)) = iter.next() { if !first.is_lowercase() { @@ -73,52 +73,52 @@ pub fn camel_case_from(s: &str) -> usize { #[cfg(test)] mod test { - use super::{camel_case_from, camel_case_until}; + use super::{from, until}; #[test] fn from_full() { - assert_eq!(camel_case_from("AbcDef"), 0); - assert_eq!(camel_case_from("Abc"), 0); + assert_eq!(from("AbcDef"), 0); + assert_eq!(from("Abc"), 0); } #[test] fn from_partial() { - assert_eq!(camel_case_from("abcDef"), 3); - assert_eq!(camel_case_from("aDbc"), 1); + assert_eq!(from("abcDef"), 3); + assert_eq!(from("aDbc"), 1); } #[test] fn from_not() { - assert_eq!(camel_case_from("AbcDef_"), 7); - assert_eq!(camel_case_from("AbcDD"), 5); + assert_eq!(from("AbcDef_"), 7); + assert_eq!(from("AbcDD"), 5); } #[test] fn from_caps() { - assert_eq!(camel_case_from("ABCD"), 4); + assert_eq!(from("ABCD"), 4); } #[test] fn until_full() { - assert_eq!(camel_case_until("AbcDef"), 6); - assert_eq!(camel_case_until("Abc"), 3); + assert_eq!(until("AbcDef"), 6); + assert_eq!(until("Abc"), 3); } #[test] fn until_not() { - assert_eq!(camel_case_until("abcDef"), 0); - assert_eq!(camel_case_until("aDbc"), 0); + assert_eq!(until("abcDef"), 0); + assert_eq!(until("aDbc"), 0); } #[test] fn until_partial() { - assert_eq!(camel_case_until("AbcDef_"), 6); - assert_eq!(camel_case_until("CallTypeC"), 8); - assert_eq!(camel_case_until("AbcDD"), 3); + assert_eq!(until("AbcDef_"), 6); + assert_eq!(until("CallTypeC"), 8); + assert_eq!(until("AbcDD"), 3); } #[test] fn until_caps() { - assert_eq!(camel_case_until("ABCD"), 0); + assert_eq!(until("ABCD"), 0); } -} \ No newline at end of file +} diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs index 2a9b1cb0a102..05356f8d3856 100644 --- a/clippy_lints/src/utils/mod.rs +++ b/clippy_lints/src/utils/mod.rs @@ -33,8 +33,7 @@ use crate::syntax::source_map::{Span, DUMMY_SP}; use crate::syntax::errors::DiagnosticBuilder; use crate::syntax::symbol::keywords; -mod camel_case; -pub use self::camel_case::{camel_case_from, camel_case_until}; +pub mod camel_case; pub mod comparisons; pub mod conf; From 73ba33dd2b22c4b434a9189304c39f8dfa608f70 Mon Sep 17 00:00:00 2001 From: Devon Hollowood Date: Thu, 11 Oct 2018 15:43:13 -0700 Subject: [PATCH 3/4] Fix `doc_markdown` lints --- clippy_lints/src/excessive_precision.rs | 1 + clippy_lints/src/map_unit_fn.rs | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/clippy_lints/src/excessive_precision.rs b/clippy_lints/src/excessive_precision.rs index 99668880f72e..15a8d47337aa 100644 --- a/clippy_lints/src/excessive_precision.rs +++ b/clippy_lints/src/excessive_precision.rs @@ -108,6 +108,7 @@ impl ExcessivePrecision { } } +#[allow(clippy::doc_markdown)] /// Should we exclude the float because it has a `.0` or `.` suffix /// Ex 1_000_000_000.0 /// Ex 1_000_000_000. diff --git a/clippy_lints/src/map_unit_fn.rs b/clippy_lints/src/map_unit_fn.rs index e620a1815ce8..503a2ee7032e 100644 --- a/clippy_lints/src/map_unit_fn.rs +++ b/clippy_lints/src/map_unit_fn.rs @@ -179,7 +179,7 @@ fn unit_closure<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'a hir::Expr) -> Op None } -/// Builds a name for the let binding variable (var_arg) +/// Builds a name for the let binding variable (`var_arg`) /// /// `x.field` => `x_field` /// `y` => `_y` From 335bc1e820c2fd1316e3c225189361b43f2654c3 Mon Sep 17 00:00:00 2001 From: Devon Hollowood Date: Fri, 12 Oct 2018 17:07:48 -0700 Subject: [PATCH 4/4] Fix some more `stutter` warnings --- clippy_lints/src/double_comparison.rs | 9 ++++----- clippy_lints/src/lib.rs | 4 ++-- clippy_lints/src/question_mark.rs | 9 ++++----- 3 files changed, 10 insertions(+), 12 deletions(-) diff --git a/clippy_lints/src/double_comparison.rs b/clippy_lints/src/double_comparison.rs index 314ca41ba21c..0171ac1e784f 100644 --- a/clippy_lints/src/double_comparison.rs +++ b/clippy_lints/src/double_comparison.rs @@ -40,16 +40,15 @@ declare_clippy_lint! { "unnecessary double comparisons that can be simplified" } -#[allow(clippy::stutter)] -pub struct DoubleComparisonPass; +pub struct Pass; -impl LintPass for DoubleComparisonPass { +impl LintPass for Pass { fn get_lints(&self) -> LintArray { lint_array!(DOUBLE_COMPARISONS) } } -impl<'a, 'tcx> DoubleComparisonPass { +impl<'a, 'tcx> Pass { #[allow(clippy::similar_names)] fn check_binop( &self, @@ -89,7 +88,7 @@ impl<'a, 'tcx> DoubleComparisonPass { } } -impl<'a, 'tcx> LateLintPass<'a, 'tcx> for DoubleComparisonPass { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if let ExprKind::Binary(ref kind, ref lhs, ref rhs) = expr.node { self.check_binop(cx, kind.node, lhs, rhs, expr.span); diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs index c343cf364f63..9b749bdcebee 100644 --- a/clippy_lints/src/lib.rs +++ b/clippy_lints/src/lib.rs @@ -428,8 +428,8 @@ pub fn register_plugins(reg: &mut rustc_plugin::Registry<'_>, conf: &Conf) { reg.register_late_lint_pass(box fallible_impl_from::FallibleImplFrom); reg.register_late_lint_pass(box replace_consts::ReplaceConsts); reg.register_late_lint_pass(box types::UnitArg); - reg.register_late_lint_pass(box double_comparison::DoubleComparisonPass); - reg.register_late_lint_pass(box question_mark::QuestionMarkPass); + reg.register_late_lint_pass(box double_comparison::Pass); + reg.register_late_lint_pass(box question_mark::Pass); reg.register_late_lint_pass(box suspicious_trait_impl::SuspiciousImpl); reg.register_early_lint_pass(box multiple_crate_versions::Pass); reg.register_late_lint_pass(box map_unit_fn::Pass); diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs index 93a40e13540f..72d33e58cd30 100644 --- a/clippy_lints/src/question_mark.rs +++ b/clippy_lints/src/question_mark.rs @@ -44,17 +44,16 @@ declare_clippy_lint!{ "checks for expressions that could be replaced by the question mark operator" } -#[allow(clippy::stutter)] #[derive(Copy, Clone)] -pub struct QuestionMarkPass; +pub struct Pass; -impl LintPass for QuestionMarkPass { +impl LintPass for Pass { fn get_lints(&self) -> LintArray { lint_array!(QUESTION_MARK) } } -impl QuestionMarkPass { +impl Pass { /// Check if the given expression on the given context matches the following structure: /// /// ```ignore @@ -146,7 +145,7 @@ impl QuestionMarkPass { } } -impl<'a, 'tcx> LateLintPass<'a, 'tcx> for QuestionMarkPass { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { Self::check_is_none_and_early_return_none(cx, expr); }