From 06ca1fc0a6d88ff5fbe0dabcc595687861c8c9b1 Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Tue, 1 Mar 2016 10:13:54 +0100 Subject: [PATCH] lint on binding-names that are too similar --- Cargo.toml | 1 + README.md | 1 + src/consts.rs | 7 +- src/lib.rs | 6 + src/non_expressive_names.rs | 150 +++++++++++++++++++++ src/types.rs | 6 +- src/utils/hir.rs | 46 +++---- src/utils/mod.rs | 4 +- tests/compile-fail/approx_const.rs | 2 +- tests/compile-fail/drop_ref.rs | 2 +- tests/compile-fail/for_loop.rs | 2 +- tests/compile-fail/len_zero.rs | 28 ++-- tests/compile-fail/methods.rs | 1 + tests/compile-fail/non_expressive_names.rs | 37 +++++ 14 files changed, 245 insertions(+), 48 deletions(-) create mode 100644 src/non_expressive_names.rs create mode 100644 tests/compile-fail/non_expressive_names.rs diff --git a/Cargo.toml b/Cargo.toml index dd675981f..844408df2 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -23,6 +23,7 @@ regex_macros = { version = "0.1.33", optional = true } semver = "0.2.1" toml = "0.1" unicode-normalization = "0.1" +strsim = "0.4.0" [dev-dependencies] compiletest_rs = "0.1.0" diff --git a/README.md b/README.md index 52223ef09..2ee4dfc5e 100644 --- a/README.md +++ b/README.md @@ -119,6 +119,7 @@ name [shadow_same](https://github.com/Manishearth/rust-clippy/wiki#shadow_same) | allow | rebinding a name to itself, e.g. `let mut x = &mut x` [shadow_unrelated](https://github.com/Manishearth/rust-clippy/wiki#shadow_unrelated) | allow | The name is re-bound without even using the original value [should_implement_trait](https://github.com/Manishearth/rust-clippy/wiki#should_implement_trait) | warn | defining a method that should be implementing a std trait +[similar_names](https://github.com/Manishearth/rust-clippy/wiki#similar_names) | warn | similarly named items and bindings [single_char_pattern](https://github.com/Manishearth/rust-clippy/wiki#single_char_pattern) | warn | using a single-character str where a char could be used, e.g. `_.split("x")` [single_match](https://github.com/Manishearth/rust-clippy/wiki#single_match) | warn | a match statement with a single nontrivial arm (i.e, where the other arm is `_ => {}`) is used; recommends `if let` instead [single_match_else](https://github.com/Manishearth/rust-clippy/wiki#single_match_else) | allow | a match statement with a two arms where the second arm's pattern is a wildcard; recommends `if let` instead diff --git a/src/consts.rs b/src/consts.rs index 3e08f1b74..f04ad1d21 100644 --- a/src/consts.rs +++ b/src/consts.rs @@ -82,7 +82,7 @@ impl Constant { impl PartialEq for Constant { fn eq(&self, other: &Constant) -> bool { match (self, other) { - (&Constant::Str(ref ls, ref lsty), &Constant::Str(ref rs, ref rsty)) => ls == rs && lsty == rsty, + (&Constant::Str(ref ls, ref l_sty), &Constant::Str(ref rs, ref r_sty)) => ls == rs && l_sty == r_sty, (&Constant::Binary(ref l), &Constant::Binary(ref r)) => l == r, (&Constant::Char(l), &Constant::Char(r)) => l == r, (&Constant::Int(l), &Constant::Int(r)) => l.is_negative() == r.is_negative() && l.to_u64_unchecked() == r.to_u64_unchecked(), @@ -145,8 +145,8 @@ impl Hash for Constant { impl PartialOrd for Constant { fn partial_cmp(&self, other: &Constant) -> Option { match (self, other) { - (&Constant::Str(ref ls, ref lsty), &Constant::Str(ref rs, ref rsty)) => { - if lsty == rsty { + (&Constant::Str(ref ls, ref l_sty), &Constant::Str(ref rs, ref r_sty)) => { + if l_sty == r_sty { Some(ls.cmp(rs)) } else { None @@ -354,6 +354,7 @@ impl<'c, 'cc> ConstEvalLateContext<'c, 'cc> { } } + fn binop_apply(&mut self, left: &Expr, right: &Expr, op: F) -> Option where F: Fn(Constant, Constant) -> Option { diff --git a/src/lib.rs b/src/lib.rs index 17f35e075..ef6b1f3a2 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -31,6 +31,9 @@ extern crate unicode_normalization; // for semver check in attrs.rs extern crate semver; +// for levensthein distance +extern crate strsim; + // for regex checking extern crate regex_syntax; @@ -84,6 +87,7 @@ pub mod needless_features; pub mod needless_update; pub mod new_without_default; pub mod no_effect; +pub mod non_expressive_names; pub mod open_options; pub mod overflow_check_conditional; pub mod panic; @@ -200,6 +204,7 @@ pub fn plugin_registrar(reg: &mut Registry) { reg.register_late_lint_pass(box types::CharLitAsU8); reg.register_late_lint_pass(box print::PrintLint); reg.register_late_lint_pass(box vec::UselessVec); + reg.register_early_lint_pass(box non_expressive_names::SimilarNames(1)); reg.register_late_lint_pass(box drop_ref::DropRefPass); reg.register_late_lint_pass(box types::AbsurdExtremeComparisons); reg.register_late_lint_pass(box regex::RegexPass::default()); @@ -326,6 +331,7 @@ pub fn plugin_registrar(reg: &mut Registry) { needless_update::NEEDLESS_UPDATE, new_without_default::NEW_WITHOUT_DEFAULT, no_effect::NO_EFFECT, + non_expressive_names::SIMILAR_NAMES, open_options::NONSENSICAL_OPEN_OPTIONS, overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL, panic::PANIC_PARAMS, diff --git a/src/non_expressive_names.rs b/src/non_expressive_names.rs new file mode 100644 index 000000000..944dcaeb0 --- /dev/null +++ b/src/non_expressive_names.rs @@ -0,0 +1,150 @@ +use rustc::lint::*; +use syntax::codemap::Span; +use syntax::parse::token::InternedString; +use syntax::ast::*; +use syntax::visit::{self, FnKind}; +use utils::{span_note_and_lint, in_macro}; +use strsim::levenshtein; + +/// **What it does:** This lint warns about names that are very similar and thus confusing +/// +/// **Why is this bad?** It's hard to distinguish between names that differ only by a single character +/// +/// **Known problems:** None? +/// +/// **Example:** `checked_exp` and `checked_expr` +declare_lint! { + pub SIMILAR_NAMES, + Warn, + "similarly named items and bindings" +} + +pub struct SimilarNames(pub usize); + +impl LintPass for SimilarNames { + fn get_lints(&self) -> LintArray { + lint_array!(SIMILAR_NAMES) + } +} + +struct SimilarNamesLocalVisitor<'a, 'b: 'a> { + names: Vec<(InternedString, Span)>, + cx: &'a EarlyContext<'b>, + limit: usize, +} + +const WHITELIST: &'static [&'static str] = &[ + "lhs", "rhs", +]; + +struct SimilarNamesNameVisitor<'a, 'b: 'a, 'c: 'b>(&'a mut SimilarNamesLocalVisitor<'b, 'c>); + +impl<'v, 'a, 'b, 'c> visit::Visitor<'v> for SimilarNamesNameVisitor<'a, 'b, 'c> { + fn visit_pat(&mut self, pat: &'v Pat) { + if let PatKind::Ident(_, id, _) = pat.node { + self.check_name(id.span, id.node.name); + } + visit::walk_pat(self, pat); + } +} + +impl<'a, 'b, 'c> SimilarNamesNameVisitor<'a, 'b, 'c> { + fn check_name(&mut self, span: Span, name: Name) { + if in_macro(self.0.cx, span) { + return; + } + let interned_name = name.as_str(); + if interned_name.chars().any(char::is_uppercase) { + return; + } + if interned_name.chars().count() < 3 { + return; + } + for &allow in WHITELIST { + if interned_name == allow { + return; + } + if interned_name.len() <= allow.len() { + continue; + } + // allow_* + let allow_start = allow.chars().chain(Some('_')); + if interned_name.chars().zip(allow_start).all(|(l, r)| l == r) { + return; + } + // *_allow + let allow_end = Some('_').into_iter().chain(allow.chars()); + if interned_name.chars().rev().zip(allow_end.rev()).all(|(l, r)| l == r) { + return; + } + } + for &(ref existing_name, sp) in &self.0.names { + let dist = levenshtein(&interned_name, &existing_name); + // equality is caught by shadow lints + if dist == 0 { + continue; + } + // if they differ enough it's all good + if dist > self.0.limit { + continue; + } + // are we doing stuff like `for item in items`? + if interned_name.starts_with(&**existing_name) || + existing_name.starts_with(&*interned_name) || + interned_name.ends_with(&**existing_name) || + existing_name.ends_with(&*interned_name) { + continue; + } + if dist == 1 { + // are we doing stuff like a_bar, b_bar, c_bar? + if interned_name.chars().next() != existing_name.chars().next() && interned_name.chars().nth(1) == Some('_') { + continue; + } + // are we doing stuff like foo_x, foo_y, foo_z? + if interned_name.chars().rev().next() != existing_name.chars().rev().next() && interned_name.chars().rev().nth(1) == Some('_') { + continue; + } + } + span_note_and_lint(self.0.cx, SIMILAR_NAMES, span, "binding's name is too similar to existing binding", sp, "existing binding defined here"); + return; + } + self.0.names.push((interned_name, span)); + } +} + +impl<'v, 'a, 'b> visit::Visitor<'v> for SimilarNamesLocalVisitor<'a, 'b> { + fn visit_local(&mut self, local: &'v Local) { + SimilarNamesNameVisitor(self).visit_local(local) + } + fn visit_block(&mut self, blk: &'v Block) { + // ensure scoping rules work + let n = self.names.len(); + visit::walk_block(self, blk); + self.names.truncate(n); + } + fn visit_arm(&mut self, arm: &'v Arm) { + let n = self.names.len(); + // just go through the first pattern, as either all patterns bind the same bindings or rustc would have errored much earlier + SimilarNamesNameVisitor(self).visit_pat(&arm.pats[0]); + self.names.truncate(n); + } + fn visit_item(&mut self, _: &'v Item) { + // do nothing + } +} + +impl EarlyLintPass for SimilarNames { + fn check_fn(&mut self, cx: &EarlyContext, _: FnKind, decl: &FnDecl, blk: &Block, _: Span, _: NodeId) { + let mut visitor = SimilarNamesLocalVisitor { + names: Vec::new(), + cx: cx, + limit: self.0, + }; + // initialize with function arguments + for arg in &decl.inputs { + visit::walk_pat(&mut SimilarNamesNameVisitor(&mut visitor), &arg.pat); + } + // walk all other bindings + visit::walk_block(&mut visitor, blk); + } +} diff --git a/src/types.rs b/src/types.rs index c5acbb41e..1dc1f55b7 100644 --- a/src/types.rs +++ b/src/types.rs @@ -638,7 +638,7 @@ fn detect_absurd_comparison<'a>(cx: &LateContext, op: BinOp_, lhs: &'a Expr, rhs Lt, Le, }; - let (rel, lhs2, rhs2) = match op { + let (rel, normalized_lhs, normalized_rhs) = match op { BiLt => (Rel::Lt, lhs, rhs), BiLe => (Rel::Le, lhs, rhs), BiGt => (Rel::Lt, rhs, lhs), @@ -646,8 +646,8 @@ fn detect_absurd_comparison<'a>(cx: &LateContext, op: BinOp_, lhs: &'a Expr, rhs _ => return None, }; - let lx = detect_extreme_expr(cx, lhs2); - let rx = detect_extreme_expr(cx, rhs2); + let lx = detect_extreme_expr(cx, normalized_lhs); + let rx = detect_extreme_expr(cx, normalized_rhs); Some(match rel { Rel::Lt => { diff --git a/src/utils/hir.rs b/src/utils/hir.rs index b4b786f97..bc7bc358a 100644 --- a/src/utils/hir.rs +++ b/src/utils/hir.rs @@ -67,24 +67,24 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { } match (&left.node, &right.node) { - (&ExprAddrOf(lmut, ref le), &ExprAddrOf(rmut, ref re)) => lmut == rmut && self.eq_expr(le, re), + (&ExprAddrOf(l_mut, ref le), &ExprAddrOf(r_mut, ref re)) => l_mut == r_mut && self.eq_expr(le, re), (&ExprAgain(li), &ExprAgain(ri)) => both(&li, &ri, |l, r| l.node.name.as_str() == r.node.name.as_str()), (&ExprAssign(ref ll, ref lr), &ExprAssign(ref rl, ref rr)) => self.eq_expr(ll, rl) && self.eq_expr(lr, rr), (&ExprAssignOp(ref lo, ref ll, ref lr), &ExprAssignOp(ref ro, ref rl, ref rr)) => { lo.node == ro.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr) } (&ExprBlock(ref l), &ExprBlock(ref r)) => self.eq_block(l, r), - (&ExprBinary(lop, ref ll, ref lr), &ExprBinary(rop, ref rl, ref rr)) => { - lop.node == rop.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr) + (&ExprBinary(l_op, ref ll, ref lr), &ExprBinary(r_op, ref rl, ref rr)) => { + l_op.node == r_op.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr) } (&ExprBreak(li), &ExprBreak(ri)) => both(&li, &ri, |l, r| l.node.name.as_str() == r.node.name.as_str()), (&ExprBox(ref l), &ExprBox(ref r)) => self.eq_expr(l, r), - (&ExprCall(ref lfun, ref largs), &ExprCall(ref rfun, ref rargs)) => { - !self.ignore_fn && self.eq_expr(lfun, rfun) && self.eq_exprs(largs, rargs) + (&ExprCall(ref l_fun, ref l_args), &ExprCall(ref r_fun, ref r_args)) => { + !self.ignore_fn && self.eq_expr(l_fun, r_fun) && self.eq_exprs(l_args, r_args) } (&ExprCast(ref lx, ref lt), &ExprCast(ref rx, ref rt)) => self.eq_expr(lx, rx) && self.eq_ty(lt, rt), - (&ExprField(ref lfexp, ref lfident), &ExprField(ref rfexp, ref rfident)) => { - lfident.node == rfident.node && self.eq_expr(lfexp, rfexp) + (&ExprField(ref l_f_exp, ref l_f_ident), &ExprField(ref r_f_exp, ref r_f_ident)) => { + l_f_ident.node == r_f_ident.node && self.eq_expr(l_f_exp, r_f_exp) } (&ExprIndex(ref la, ref li), &ExprIndex(ref ra, ref ri)) => self.eq_expr(la, ra) && self.eq_expr(li, ri), (&ExprIf(ref lc, ref lt, ref le), &ExprIf(ref rc, ref rt, ref re)) => { @@ -101,25 +101,25 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { over(&l.pats, &r.pats, |l, r| self.eq_pat(l, r)) }) } - (&ExprMethodCall(ref lname, ref ltys, ref largs), - &ExprMethodCall(ref rname, ref rtys, ref rargs)) => { + (&ExprMethodCall(ref l_name, ref l_tys, ref l_args), + &ExprMethodCall(ref r_name, ref r_tys, ref r_args)) => { // TODO: tys - !self.ignore_fn && lname.node == rname.node && ltys.is_empty() && rtys.is_empty() && - self.eq_exprs(largs, rargs) + !self.ignore_fn && l_name.node == r_name.node && l_tys.is_empty() && r_tys.is_empty() && + self.eq_exprs(l_args, r_args) } (&ExprRepeat(ref le, ref ll), &ExprRepeat(ref re, ref rl)) => self.eq_expr(le, re) && self.eq_expr(ll, rl), (&ExprRet(ref l), &ExprRet(ref r)) => both(l, r, |l, r| self.eq_expr(l, r)), - (&ExprPath(ref lqself, ref lsubpath), &ExprPath(ref rqself, ref rsubpath)) => { - both(lqself, rqself, |l, r| self.eq_qself(l, r)) && self.eq_path(lsubpath, rsubpath) + (&ExprPath(ref l_qself, ref l_subpath), &ExprPath(ref r_qself, ref r_subpath)) => { + both(l_qself, r_qself, |l, r| self.eq_qself(l, r)) && self.eq_path(l_subpath, r_subpath) } - (&ExprStruct(ref lpath, ref lf, ref lo), &ExprStruct(ref rpath, ref rf, ref ro)) => { - self.eq_path(lpath, rpath) && + (&ExprStruct(ref l_path, ref lf, ref lo), &ExprStruct(ref r_path, ref rf, ref ro)) => { + self.eq_path(l_path, r_path) && both(lo, ro, |l, r| self.eq_expr(l, r)) && over(lf, rf, |l, r| self.eq_field(l, r)) } - (&ExprTup(ref ltup), &ExprTup(ref rtup)) => self.eq_exprs(ltup, rtup), + (&ExprTup(ref l_tup), &ExprTup(ref r_tup)) => self.eq_exprs(l_tup, r_tup), (&ExprTupField(ref le, li), &ExprTupField(ref re, ri)) => li.node == ri.node && self.eq_expr(le, re), - (&ExprUnary(lop, ref le), &ExprUnary(rop, ref re)) => lop == rop && self.eq_expr(le, re), + (&ExprUnary(l_op, ref le), &ExprUnary(r_op, ref re)) => l_op == r_op && self.eq_expr(le, re), (&ExprVec(ref l), &ExprVec(ref r)) => self.eq_exprs(l, r), (&ExprWhile(ref lc, ref lb, ref ll), &ExprWhile(ref rc, ref rb, ref rl)) => { self.eq_expr(lc, rc) && self.eq_block(lb, rb) && both(ll, rl, |l, r| l.name.as_str() == r.name.as_str()) @@ -179,16 +179,16 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { fn eq_ty(&self, left: &Ty, right: &Ty) -> bool { match (&left.node, &right.node) { - (&TyVec(ref lvec), &TyVec(ref rvec)) => self.eq_ty(lvec, rvec), + (&TyVec(ref l_vec), &TyVec(ref r_vec)) => self.eq_ty(l_vec, r_vec), (&TyFixedLengthVec(ref lt, ref ll), &TyFixedLengthVec(ref rt, ref rl)) => { self.eq_ty(lt, rt) && self.eq_expr(ll, rl) } - (&TyPtr(ref lmut), &TyPtr(ref rmut)) => lmut.mutbl == rmut.mutbl && self.eq_ty(&*lmut.ty, &*rmut.ty), - (&TyRptr(_, ref lrmut), &TyRptr(_, ref rrmut)) => { - lrmut.mutbl == rrmut.mutbl && self.eq_ty(&*lrmut.ty, &*rrmut.ty) + (&TyPtr(ref l_mut), &TyPtr(ref r_mut)) => l_mut.mutbl == r_mut.mutbl && self.eq_ty(&*l_mut.ty, &*r_mut.ty), + (&TyRptr(_, ref l_rmut), &TyRptr(_, ref r_rmut)) => { + l_rmut.mutbl == r_rmut.mutbl && self.eq_ty(&*l_rmut.ty, &*r_rmut.ty) } - (&TyPath(ref lq, ref lpath), &TyPath(ref rq, ref rpath)) => { - both(lq, rq, |l, r| self.eq_qself(l, r)) && self.eq_path(lpath, rpath) + (&TyPath(ref lq, ref l_path), &TyPath(ref rq, ref r_path)) => { + both(lq, rq, |l, r| self.eq_qself(l, r)) && self.eq_path(l_path, r_path) } (&TyTup(ref l), &TyTup(ref r)) => over(l, r, |l, r| self.eq_ty(l, r)), (&TyInfer, &TyInfer) => true, diff --git a/src/utils/mod.rs b/src/utils/mod.rs index 2934f1c4f..de303a35f 100644 --- a/src/utils/mod.rs +++ b/src/utils/mod.rs @@ -102,8 +102,8 @@ macro_rules! if_let_chain { /// Returns true if the two spans come from differing expansions (i.e. one is from a macro and one /// isn't). -pub fn differing_macro_contexts(sp1: Span, sp2: Span) -> bool { - sp1.expn_id != sp2.expn_id +pub fn differing_macro_contexts(lhs: Span, rhs: Span) -> bool { + rhs.expn_id != lhs.expn_id } /// Returns true if this `expn_info` was expanded by any macro. pub fn in_macro(cx: &T, span: Span) -> bool { diff --git a/tests/compile-fail/approx_const.rs b/tests/compile-fail/approx_const.rs index 148746bfa..3660fb419 100644 --- a/tests/compile-fail/approx_const.rs +++ b/tests/compile-fail/approx_const.rs @@ -2,7 +2,7 @@ #![plugin(clippy)] #[deny(approx_constant)] -#[allow(unused, shadow_unrelated)] +#[allow(unused, shadow_unrelated, similar_names)] fn main() { let my_e = 2.7182; //~ERROR approximate value of `f{32, 64}::E` found let almost_e = 2.718; //~ERROR approximate value of `f{32, 64}::E` found diff --git a/tests/compile-fail/drop_ref.rs b/tests/compile-fail/drop_ref.rs index 3e4c0a9d8..8454a4715 100644 --- a/tests/compile-fail/drop_ref.rs +++ b/tests/compile-fail/drop_ref.rs @@ -2,7 +2,7 @@ #![plugin(clippy)] #![deny(drop_ref)] -#![allow(toplevel_ref_arg)] +#![allow(toplevel_ref_arg, similar_names)] use std::mem::drop; diff --git a/tests/compile-fail/for_loop.rs b/tests/compile-fail/for_loop.rs index bbdf9d8f1..b111439ba 100644 --- a/tests/compile-fail/for_loop.rs +++ b/tests/compile-fail/for_loop.rs @@ -88,7 +88,7 @@ impl Unrelated { #[deny(needless_range_loop, explicit_iter_loop, iter_next_loop, reverse_range_loop, explicit_counter_loop)] #[deny(unused_collect)] -#[allow(linkedlist, shadow_unrelated, unnecessary_mut_passed, cyclomatic_complexity)] +#[allow(linkedlist, shadow_unrelated, unnecessary_mut_passed, cyclomatic_complexity, similar_names)] fn main() { const MAX_LEN: usize = 42; diff --git a/tests/compile-fail/len_zero.rs b/tests/compile-fail/len_zero.rs index 5168f80b8..4fd0203b9 100644 --- a/tests/compile-fail/len_zero.rs +++ b/tests/compile-fail/len_zero.rs @@ -92,38 +92,38 @@ fn main() { println!("Nor should this!"); } - let hie = HasIsEmpty; - if hie.len() == 0 { + let has_is_empty = HasIsEmpty; + if has_is_empty.len() == 0 { //~^ERROR length comparison to zero //~|HELP consider using `is_empty` - //~|SUGGESTION hie.is_empty() + //~|SUGGESTION has_is_empty.is_empty() println!("Or this!"); } - if hie.len() != 0 { + if has_is_empty.len() != 0 { //~^ERROR length comparison to zero //~|HELP consider using `is_empty` - //~|SUGGESTION !hie.is_empty() + //~|SUGGESTION !has_is_empty.is_empty() println!("Or this!"); } - if hie.len() > 0 { + if has_is_empty.len() > 0 { //~^ERROR length comparison to zero //~|HELP consider using `is_empty` - //~|SUGGESTION !hie.is_empty() + //~|SUGGESTION !has_is_empty.is_empty() println!("Or this!"); } - assert!(!hie.is_empty()); + assert!(!has_is_empty.is_empty()); - let wie : &WithIsEmpty = &Wither; - if wie.len() == 0 { + let with_is_empty: &WithIsEmpty = &Wither; + if with_is_empty.len() == 0 { //~^ERROR length comparison to zero //~|HELP consider using `is_empty` - //~|SUGGESTION wie.is_empty() + //~|SUGGESTION with_is_empty.is_empty() println!("Or this!"); } - assert!(!wie.is_empty()); + assert!(!with_is_empty.is_empty()); - let hwie = HasWrongIsEmpty; - if hwie.len() == 0 { //no error as HasWrongIsEmpty does not have .is_empty() + let has_wrong_is_empty = HasWrongIsEmpty; + if has_wrong_is_empty.len() == 0 { //no error as HasWrongIsEmpty does not have .is_empty() println!("Or this!"); } } diff --git a/tests/compile-fail/methods.rs b/tests/compile-fail/methods.rs index 344016a3b..b1a8f6cf7 100644 --- a/tests/compile-fail/methods.rs +++ b/tests/compile-fail/methods.rs @@ -286,6 +286,7 @@ fn or_fun_call() { //~|SUGGESTION btree.entry(42).or_insert_with(String::new); } +#[allow(similar_names)] fn main() { use std::io; diff --git a/tests/compile-fail/non_expressive_names.rs b/tests/compile-fail/non_expressive_names.rs new file mode 100644 index 000000000..a9a06f423 --- /dev/null +++ b/tests/compile-fail/non_expressive_names.rs @@ -0,0 +1,37 @@ +#![feature(plugin)] +#![plugin(clippy)] +#![deny(clippy)] +#![allow(unused)] + +fn main() { + let specter: i32; + let spectre: i32; + + let apple: i32; //~ NOTE: existing binding defined here + let bpple: i32; //~ ERROR: name is too similar + let cpple: i32; //~ ERROR: name is too similar + + let a_bar: i32; + let b_bar: i32; + let c_bar: i32; + + let foo_x: i32; + let foo_y: i32; + + let rhs: i32; + let lhs: i32; + + let bla_rhs: i32; + let bla_lhs: i32; + + let blubrhs: i32; //~ NOTE: existing binding defined here + let blublhs: i32; //~ ERROR: name is too similar + + let blubx: i32; //~ NOTE: existing binding defined here + let bluby: i32; //~ ERROR: name is too similar + + let cake: i32; //~ NOTE: existing binding defined here + let caked: i32; //~ NOTE: existing binding defined here + let cakes: i32; //~ ERROR: name is too similar + let coke: i32; //~ ERROR: name is too similar +}