From f71d59e6a63d8624a121d29230a83ae39c856c6c Mon Sep 17 00:00:00 2001 From: xd009642 Date: Fri, 15 Feb 2019 20:21:13 +0000 Subject: [PATCH 01/13] Lint for type repetition in trait bounds. This lint adds warning if types are redundantly repeated in trait bounds i.e. `T: Copy, T: Clone` instead of `T: Copy + Clone`. This is a late pass trait lint and has necessitated the addition of code to allow hashing of TyKinds without taking into account Span information. --- clippy_lints/src/lib.rs | 3 + clippy_lints/src/trait_bounds.rs | 63 ++++++++++++ clippy_lints/src/utils/hir_utils.rs | 119 +++++++++++++++++++++- tests/ui/type_repetition_in_bounds.rs | 14 +++ tests/ui/type_repetition_in_bounds.stderr | 15 +++ 5 files changed, 210 insertions(+), 4 deletions(-) create mode 100644 clippy_lints/src/trait_bounds.rs create mode 100644 tests/ui/type_repetition_in_bounds.rs create mode 100644 tests/ui/type_repetition_in_bounds.stderr diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs index 6d90d315f0054..faffb1a67f1a2 100644 --- a/clippy_lints/src/lib.rs +++ b/clippy_lints/src/lib.rs @@ -265,6 +265,7 @@ pub mod swap; pub mod temporary_assignment; pub mod transmute; pub mod transmuting_null; +pub mod trait_bounds; pub mod trivially_copy_pass_by_ref; pub mod try_err; pub mod types; @@ -588,6 +589,7 @@ pub fn register_plugins(reg: &mut rustc_plugin::Registry<'_>, conf: &Conf) { reg.register_late_lint_pass(box checked_conversions::CheckedConversions); reg.register_late_lint_pass(box integer_division::IntegerDivision); reg.register_late_lint_pass(box inherent_to_string::InherentToString); + reg.register_late_lint_pass(box trait_bounds::TraitBounds); reg.register_lint_group("clippy::restriction", Some("clippy_restriction"), vec![ arithmetic::FLOAT_ARITHMETIC, @@ -868,6 +870,7 @@ pub fn register_plugins(reg: &mut rustc_plugin::Registry<'_>, conf: &Conf) { transmute::USELESS_TRANSMUTE, transmute::WRONG_TRANSMUTE, transmuting_null::TRANSMUTING_NULL, + trait_bounds::TYPE_REPETITION_IN_BOUNDS, trivially_copy_pass_by_ref::TRIVIALLY_COPY_PASS_BY_REF, try_err::TRY_ERR, types::ABSURD_EXTREME_COMPARISONS, diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs new file mode 100644 index 0000000000000..1f4c685076045 --- /dev/null +++ b/clippy_lints/src/trait_bounds.rs @@ -0,0 +1,63 @@ +use crate::utils::{in_macro, span_help_and_lint, SpanlessHash}; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_tool_lint, lint_array}; +use rustc_data_structures::fx::FxHashMap; +use rustc::hir::*; + +declare_clippy_lint! { + pub TYPE_REPETITION_IN_BOUNDS, + complexity, + "Types are repeated unnecessary in trait bounds use `+` instead of using `T: _, T: _`" +} + +#[derive(Copy, Clone)] +pub struct TraitBounds; + +impl LintPass for TraitBounds { + fn get_lints(&self) -> LintArray { + lint_array!(TYPE_REPETITION_IN_BOUNDS) + } + + fn name(&self) -> &'static str { + "TypeRepetitionInBounds" + } +} + + + +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TraitBounds { + fn check_generics(&mut self, cx: &LateContext<'a, 'tcx>, gen: &'tcx Generics) { + if in_macro(gen.span) { + return; + } + let hash = | ty | -> u64 { + let mut hasher = SpanlessHash::new(cx, cx.tables); + hasher.hash_ty(ty); + hasher.finish() + }; + let mut map = FxHashMap::default(); + for bound in &gen.where_clause.predicates { + if let WherePredicate::BoundPredicate(ref p) = bound { + let h = hash(&p.bounded_ty); + if let Some(ref v) = map.insert(h, p.bounds) { + let mut hint_string = format!("consider combining the bounds: `{:?}: ", p.bounded_ty); + for &b in v.iter() { + hint_string.push_str(&format!("{:?}, ", b)); + } + for &b in p.bounds.iter() { + hint_string.push_str(&format!("{:?}, ", b)); + } + hint_string.truncate(hint_string.len() - 2); + hint_string.push('`'); + span_help_and_lint( + cx, + TYPE_REPETITION_IN_BOUNDS, + p.span, + "this type has already been used as a bound predicate", + &hint_string, + ); + } + } + } + } +} diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs index e9b5cee430e7c..929c15a6ee55e 100644 --- a/clippy_lints/src/utils/hir_utils.rs +++ b/clippy_lints/src/utils/hir_utils.rs @@ -3,7 +3,7 @@ use crate::utils::differing_macro_contexts; use rustc::hir::ptr::P; use rustc::hir::*; use rustc::lint::LateContext; -use rustc::ty::TypeckTables; +use rustc::ty::{Ty, TypeckTables}; use std::collections::hash_map::DefaultHasher; use std::hash::{Hash, Hasher}; use syntax::ast::Name; @@ -438,9 +438,11 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> { self.hash_expr(fun); self.hash_exprs(args); }, - ExprKind::Cast(ref e, ref _ty) | ExprKind::Type(ref e, ref _ty) => { + ExprKind::Cast(ref e, ref ty) => { + let c: fn(_, _) -> _ = ExprKind::Cast; + c.hash(&mut self.s); self.hash_expr(e); - // TODO: _ty + self.hash_ty(ty); }, ExprKind::Closure(cap, _, eid, _, _) => { match cap { @@ -512,9 +514,22 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> { self.hash_expr(e); } }, - ExprKind::Tup(ref v) | ExprKind::Array(ref v) => { + ExprKind::Tup(ref tup) => { + let c: fn(_) -> _ = ExprKind::Tup; + c.hash(&mut self.s); + self.hash_exprs(tup); + }, + ExprKind::Array(ref v) => { + let c: fn(_) -> _ = ExprKind::Array; + c.hash(&mut self.s); self.hash_exprs(v); }, + ExprKind::Type(ref e, ref ty) => { + let c: fn(_, _) -> _ = ExprKind::Type; + c.hash(&mut self.s); + self.hash_expr(e); + self.hash_ty(ty); + }, ExprKind::Unary(lop, ref le) => { lop.hash(&mut self.s); self.hash_expr(le); @@ -574,4 +589,100 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> { }, } } + + pub fn hash_lifetime(&mut self, lifetime: &Lifetime) { + if let LifetimeName::Param(ref name) = lifetime.name { + match name { + ParamName::Plain(ref ident) => { + ident.name.hash(&mut self.s); + }, + ParamName::Fresh(ref size) => { + size.hash(&mut self.s); + }, + _ => {}, + } + } + } + + pub fn hash_ty(&mut self, ty: &Ty) { + std::mem::discriminant(&ty.node).hash(&mut self.s); + match ty.node { + Ty::Slice(ty) => { + self.hash_ty(ty); + }, + Ty::Array(ty, anon_const) => { + self.hash_ty(ty); + self.hash_expr(&self.cx.tcx.hir().body(anon_const.body).value); + }, + Ty::Ptr(mut_ty) => { + self.hash_ty(&mut_ty.ty); + mut_ty.mutbl.hash(&mut self.s); + }, + Ty::Rptr(lifetime, mut_ty) => { + self.hash_lifetime(lifetime); + self.hash_ty(&mut_ty.ty); + mut_ty.mutbl.hash(&mut self.s); + }, + Ty::BareFn(bfn) => { + bfn.unsafety.hash(&mut self.s); + bfn.abi.hash(&mut self.s); + for arg in &bfn.decl.inputs { + self.hash_ty(&arg); + } + match bfn.decl.output { + FunctionRetTy::DefaultReturn(_) => { + ().hash(&mut self.s); + }, + FunctionRetTy::Return(ref ty) => { + self.hash_ty(ty); + }, + } + bfn.decl.c_variadic.hash(&mut self.s); + }, + Ty::Tup(ty_list) => { + for ty in ty_list { + self.hash_ty(ty); + } + + }, + Ty::Path(qpath) => { + match qpath { + QPath::Resolved(ref maybe_ty, ref path) => { + if let Some(ref ty) = maybe_ty { + self.hash_ty(ty); + } + for segment in &path.segments { + segment.ident.name.hash(&mut self.s); + } + }, + QPath::TypeRelative(ref ty, ref segment) => { + self.hash_ty(ty); + segment.ident.name.hash(&mut self.s); + }, + } + }, + Ty::Def(_, arg_list) => { + for arg in arg_list { + match arg { + GenericArg::Lifetime(ref l) => self.hash_lifetime(l), + GenericArg::Type(ref ty) => self.hash_ty(ty), + GenericArg::Const(ref ca) => { + self.hash_expr(&self.cx.tcx.hir().body(ca.value.body).value); + }, + } + } + }, + Ty::TraitObject(_, lifetime) => { + self.hash_lifetime(lifetime); + + }, + Ty::Typeof(anon_const) => { + self.hash_expr(&self.cx.tcx.hir().body(anon_const.body).value); + }, + Ty::CVarArgs(lifetime) => { + self.hash_lifetime(lifetime); + }, + Ty::Err | Ty::Infer | Ty::Never => {}, + } + } } diff --git a/tests/ui/type_repetition_in_bounds.rs b/tests/ui/type_repetition_in_bounds.rs new file mode 100644 index 0000000000000..3aa0d0da56170 --- /dev/null +++ b/tests/ui/type_repetition_in_bounds.rs @@ -0,0 +1,14 @@ +#[deny(clippy::type_repetition_in_bounds)] + +pub fn foo(_t: T) where T: Copy, T: Clone { + unimplemented!(); +} + +pub fn bar(_t: T, _u: U) where T: Copy, U: Clone { + unimplemented!(); +} + + +fn main() { + +} diff --git a/tests/ui/type_repetition_in_bounds.stderr b/tests/ui/type_repetition_in_bounds.stderr new file mode 100644 index 0000000000000..1b49c69533ce5 --- /dev/null +++ b/tests/ui/type_repetition_in_bounds.stderr @@ -0,0 +1,15 @@ +error: this type has already been used as a bound predicate + --> $DIR/type_repetition_in_bounds.rs:3:37 + | +LL | pub fn foo(_t: T) where T: Copy, T: Clone { + | ^^^^^^^^ + | +note: lint level defined here + --> $DIR/type_repetition_in_bounds.rs:1:8 + | +LL | #[deny(clippy::type_repetition_in_bounds)] + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + = help: consider combining the bounds: `T: Copy + Clone` + +error: aborting due to previous error + From f3e4467c109364c557bfd998dabfeab6a045c605 Mon Sep 17 00:00:00 2001 From: xd009642 Date: Sat, 22 Jun 2019 22:22:11 +0100 Subject: [PATCH 02/13] Changed Ty to ty, added lifetime 'tcx --- clippy_lints/src/utils/hir_utils.rs | 34 ++++++++++++++--------------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs index 929c15a6ee55e..276d984f82061 100644 --- a/clippy_lints/src/utils/hir_utils.rs +++ b/clippy_lints/src/utils/hir_utils.rs @@ -3,7 +3,7 @@ use crate::utils::differing_macro_contexts; use rustc::hir::ptr::P; use rustc::hir::*; use rustc::lint::LateContext; -use rustc::ty::{Ty, TypeckTables}; +use rustc::ty::{self, Ty, TypeckTables}; use std::collections::hash_map::DefaultHasher; use std::hash::{Hash, Hasher}; use syntax::ast::Name; @@ -45,7 +45,7 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> { match (&left.node, &right.node) { (&StmtKind::Local(ref l), &StmtKind::Local(ref r)) => { self.eq_pat(&l.pat, &r.pat) - && both(&l.ty, &r.ty, |l, r| self.eq_ty(l, r)) + && both(&l.ty, &r.ty, |l, r| self.eq_ty(*l, *r)) && both(&l.init, &r.init, |l, r| self.eq_expr(l, r)) }, (&StmtKind::Expr(ref l), &StmtKind::Expr(ref r)) | (&StmtKind::Semi(ref l), &StmtKind::Semi(ref r)) => { @@ -257,7 +257,7 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> { } } - pub fn eq_ty(&mut self, left: &Ty, right: &Ty) -> bool { + pub fn eq_ty(&mut self, left: &Ty<'tcx>, right: &Ty<'tcx>) -> bool { self.eq_ty_kind(&left.node, &right.node) } @@ -604,26 +604,26 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> { } } - pub fn hash_ty(&mut self, ty: &Ty) { + pub fn hash_ty(&mut self, ty: &Ty<'tcx>) { std::mem::discriminant(&ty.node).hash(&mut self.s); - match ty.node { - Ty::Slice(ty) => { + match ty.sty { + ty::Slice(ty) => { self.hash_ty(ty); }, - Ty::Array(ty, anon_const) => { + ty::Array(ty, anon_const) => { self.hash_ty(ty); self.hash_expr(&self.cx.tcx.hir().body(anon_const.body).value); }, - Ty::Ptr(mut_ty) => { + ty::Ptr(mut_ty) => { self.hash_ty(&mut_ty.ty); mut_ty.mutbl.hash(&mut self.s); }, - Ty::Rptr(lifetime, mut_ty) => { + ty::Rptr(lifetime, mut_ty) => { self.hash_lifetime(lifetime); self.hash_ty(&mut_ty.ty); mut_ty.mutbl.hash(&mut self.s); }, - Ty::BareFn(bfn) => { + ty::BareFn(bfn) => { bfn.unsafety.hash(&mut self.s); bfn.abi.hash(&mut self.s); for arg in &bfn.decl.inputs { @@ -639,13 +639,13 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> { } bfn.decl.c_variadic.hash(&mut self.s); }, - Ty::Tup(ty_list) => { + ty::Tup(ty_list) => { for ty in ty_list { self.hash_ty(ty); } }, - Ty::Path(qpath) => { + ty::Path(qpath) => { match qpath { QPath::Resolved(ref maybe_ty, ref path) => { if let Some(ref ty) = maybe_ty { @@ -661,7 +661,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> { }, } }, - Ty::Def(_, arg_list) => { + ty::Def(_, arg_list) => { for arg in arg_list { match arg { GenericArg::Lifetime(ref l) => self.hash_lifetime(l), @@ -672,17 +672,17 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> { } } }, - Ty::TraitObject(_, lifetime) => { + ty::TraitObject(_, lifetime) => { self.hash_lifetime(lifetime); }, - Ty::Typeof(anon_const) => { + ty::Typeof(anon_const) => { self.hash_expr(&self.cx.tcx.hir().body(anon_const.body).value); }, - Ty::CVarArgs(lifetime) => { + ty::CVarArgs(lifetime) => { self.hash_lifetime(lifetime); }, - Ty::Err | Ty::Infer | Ty::Never => {}, + ty::Err | ty::Infer | ty::Never => {}, } } } From 792153104c5af9948df6d8def8ab4b2611731eb6 Mon Sep 17 00:00:00 2001 From: xd009642 Date: Wed, 24 Jul 2019 22:27:12 +0100 Subject: [PATCH 03/13] Fix some of the compile errors --- clippy_lints/src/trait_bounds.rs | 22 ++++++-------------- clippy_lints/src/utils/hir_utils.rs | 32 ++++++++++++++--------------- 2 files changed, 22 insertions(+), 32 deletions(-) diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs index 1f4c685076045..e41437bf1f825 100644 --- a/clippy_lints/src/trait_bounds.rs +++ b/clippy_lints/src/trait_bounds.rs @@ -1,29 +1,19 @@ use crate::utils::{in_macro, span_help_and_lint, SpanlessHash}; use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use rustc::{declare_tool_lint, lint_array}; +use rustc::{declare_tool_lint, lint_array, impl_lint_pass}; use rustc_data_structures::fx::FxHashMap; use rustc::hir::*; +#[derive(Copy, Clone)] +pub struct TraitBounds; + declare_clippy_lint! { pub TYPE_REPETITION_IN_BOUNDS, complexity, "Types are repeated unnecessary in trait bounds use `+` instead of using `T: _, T: _`" } -#[derive(Copy, Clone)] -pub struct TraitBounds; - -impl LintPass for TraitBounds { - fn get_lints(&self) -> LintArray { - lint_array!(TYPE_REPETITION_IN_BOUNDS) - } - - fn name(&self) -> &'static str { - "TypeRepetitionInBounds" - } -} - - +impl_lint_pass!(TraitBounds => [TYPE_REPETITION_IN_BOUNDS]); impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TraitBounds { fn check_generics(&mut self, cx: &LateContext<'a, 'tcx>, gen: &'tcx Generics) { @@ -38,7 +28,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TraitBounds { let mut map = FxHashMap::default(); for bound in &gen.where_clause.predicates { if let WherePredicate::BoundPredicate(ref p) = bound { - let h = hash(&p.bounded_ty); + let h = hash(&p.bounded_ty.node); if let Some(ref v) = map.insert(h, p.bounds) { let mut hint_string = format!("consider combining the bounds: `{:?}: ", p.bounded_ty); for &b in v.iter() { diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs index 276d984f82061..5304a9226ae5d 100644 --- a/clippy_lints/src/utils/hir_utils.rs +++ b/clippy_lints/src/utils/hir_utils.rs @@ -258,7 +258,7 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> { } pub fn eq_ty(&mut self, left: &Ty<'tcx>, right: &Ty<'tcx>) -> bool { - self.eq_ty_kind(&left.node, &right.node) + self.eq_ty_kind(&left.sty, &right.sty) } #[allow(clippy::similar_names)] @@ -604,26 +604,26 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> { } } - pub fn hash_ty(&mut self, ty: &Ty<'tcx>) { + pub fn hash_ty(&mut self, ty: &TyKind) { std::mem::discriminant(&ty.node).hash(&mut self.s); - match ty.sty { - ty::Slice(ty) => { + match ty { + TyKind::Slice(ty) => { self.hash_ty(ty); }, - ty::Array(ty, anon_const) => { + TyKind::Array(ty, anon_const) => { self.hash_ty(ty); self.hash_expr(&self.cx.tcx.hir().body(anon_const.body).value); }, - ty::Ptr(mut_ty) => { + TyKind::Ptr(mut_ty) => { self.hash_ty(&mut_ty.ty); mut_ty.mutbl.hash(&mut self.s); }, - ty::Rptr(lifetime, mut_ty) => { + TyKind::Rptr(lifetime, mut_ty) => { self.hash_lifetime(lifetime); self.hash_ty(&mut_ty.ty); mut_ty.mutbl.hash(&mut self.s); }, - ty::BareFn(bfn) => { + TyKind::BareFn(bfn) => { bfn.unsafety.hash(&mut self.s); bfn.abi.hash(&mut self.s); for arg in &bfn.decl.inputs { @@ -639,13 +639,13 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> { } bfn.decl.c_variadic.hash(&mut self.s); }, - ty::Tup(ty_list) => { + TyKind::Tup(ty_list) => { for ty in ty_list { self.hash_ty(ty); } }, - ty::Path(qpath) => { + TyKind::Path(qpath) => { match qpath { QPath::Resolved(ref maybe_ty, ref path) => { if let Some(ref ty) = maybe_ty { @@ -661,7 +661,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> { }, } }, - ty::Def(_, arg_list) => { + TyKind::Def(_, arg_list) => { for arg in arg_list { match arg { GenericArg::Lifetime(ref l) => self.hash_lifetime(l), @@ -672,17 +672,17 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> { } } }, - ty::TraitObject(_, lifetime) => { + TyKind::TraitObject(_, lifetime) => { self.hash_lifetime(lifetime); }, - ty::Typeof(anon_const) => { + TyKind::Typeof(anon_const) => { self.hash_expr(&self.cx.tcx.hir().body(anon_const.body).value); }, - ty::CVarArgs(lifetime) => { - self.hash_lifetime(lifetime); + TyKind::CVarArgs(lifetime) => { + self.hash_lifetime(lifetime) }, - ty::Err | ty::Infer | ty::Never => {}, + TyKind::Err | TyKind::Infer | TyKind::Never => {}, } } } From c0259179c3c867e9b25894bf8139145d34359acc Mon Sep 17 00:00:00 2001 From: xd009642 Date: Wed, 24 Jul 2019 22:59:32 +0100 Subject: [PATCH 04/13] Fixed more compile errors Moved to rustc::hir::Ty --- clippy_lints/src/trait_bounds.rs | 6 +++--- clippy_lints/src/utils/hir_utils.rs | 18 +++++++++++------- 2 files changed, 14 insertions(+), 10 deletions(-) diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs index e41437bf1f825..02514377dfb4e 100644 --- a/clippy_lints/src/trait_bounds.rs +++ b/clippy_lints/src/trait_bounds.rs @@ -28,13 +28,13 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TraitBounds { let mut map = FxHashMap::default(); for bound in &gen.where_clause.predicates { if let WherePredicate::BoundPredicate(ref p) = bound { - let h = hash(&p.bounded_ty.node); + let h = hash(&p.bounded_ty); if let Some(ref v) = map.insert(h, p.bounds) { let mut hint_string = format!("consider combining the bounds: `{:?}: ", p.bounded_ty); - for &b in v.iter() { + for b in v.iter() { hint_string.push_str(&format!("{:?}, ", b)); } - for &b in p.bounds.iter() { + for b in p.bounds.iter() { hint_string.push_str(&format!("{:?}, ", b)); } hint_string.truncate(hint_string.len() - 2); diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs index 5304a9226ae5d..4330b55878c3d 100644 --- a/clippy_lints/src/utils/hir_utils.rs +++ b/clippy_lints/src/utils/hir_utils.rs @@ -3,7 +3,7 @@ use crate::utils::differing_macro_contexts; use rustc::hir::ptr::P; use rustc::hir::*; use rustc::lint::LateContext; -use rustc::ty::{self, Ty, TypeckTables}; +use rustc::ty::{self, TypeckTables}; use std::collections::hash_map::DefaultHasher; use std::hash::{Hash, Hasher}; use syntax::ast::Name; @@ -45,7 +45,7 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> { match (&left.node, &right.node) { (&StmtKind::Local(ref l), &StmtKind::Local(ref r)) => { self.eq_pat(&l.pat, &r.pat) - && both(&l.ty, &r.ty, |l, r| self.eq_ty(*l, *r)) + && both(&l.ty, &r.ty, |l, r| self.eq_ty(l, r)) && both(&l.init, &r.init, |l, r| self.eq_expr(l, r)) }, (&StmtKind::Expr(ref l), &StmtKind::Expr(ref r)) | (&StmtKind::Semi(ref l), &StmtKind::Semi(ref r)) => { @@ -257,8 +257,8 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> { } } - pub fn eq_ty(&mut self, left: &Ty<'tcx>, right: &Ty<'tcx>) -> bool { - self.eq_ty_kind(&left.sty, &right.sty) + pub fn eq_ty(&mut self, left: &Ty, right: &Ty) -> bool { + self.eq_ty_kind(&left.node, &right.node) } #[allow(clippy::similar_names)] @@ -604,8 +604,12 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> { } } - pub fn hash_ty(&mut self, ty: &TyKind) { - std::mem::discriminant(&ty.node).hash(&mut self.s); + pub fn hash_ty(&mut self, ty: &Ty) { + self.hash_tykind(&ty.node); + } + + pub fn hash_tykind(&mut self, ty: &TyKind) { + std::mem::discriminant(&ty).hash(&mut self.s); match ty { TyKind::Slice(ty) => { self.hash_ty(ty); @@ -665,7 +669,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> { for arg in arg_list { match arg { GenericArg::Lifetime(ref l) => self.hash_lifetime(l), - GenericArg::Type(ref ty) => self.hash_ty(ty), + GenericArg::Type(ref ty) => self.hash_ty(&ty), GenericArg::Const(ref ca) => { self.hash_expr(&self.cx.tcx.hir().body(ca.value.body).value); }, From 7853dac66245d88bace4cdc62b38837aa3e54568 Mon Sep 17 00:00:00 2001 From: xd009642 Date: Fri, 26 Jul 2019 16:46:47 +0100 Subject: [PATCH 05/13] Responded to comments and fixed compile bug Removed the hash of `let c: fn(_,_) -> _ = ExprKind::Cast` and fixed compile issue by collecting HirVec into an actual Vec --- clippy_lints/src/trait_bounds.rs | 4 ++-- clippy_lints/src/utils/hir_utils.rs | 4 +--- 2 files changed, 3 insertions(+), 5 deletions(-) diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs index 02514377dfb4e..cb836eac3a6f1 100644 --- a/clippy_lints/src/trait_bounds.rs +++ b/clippy_lints/src/trait_bounds.rs @@ -1,6 +1,6 @@ use crate::utils::{in_macro, span_help_and_lint, SpanlessHash}; use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use rustc::{declare_tool_lint, lint_array, impl_lint_pass}; +use rustc::{declare_tool_lint, impl_lint_pass}; use rustc_data_structures::fx::FxHashMap; use rustc::hir::*; @@ -29,7 +29,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TraitBounds { for bound in &gen.where_clause.predicates { if let WherePredicate::BoundPredicate(ref p) = bound { let h = hash(&p.bounded_ty); - if let Some(ref v) = map.insert(h, p.bounds) { + if let Some(ref v) = map.insert(h, p.bounds.iter().collect::>()) { let mut hint_string = format!("consider combining the bounds: `{:?}: ", p.bounded_ty); for b in v.iter() { hint_string.push_str(&format!("{:?}, ", b)); diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs index 4330b55878c3d..703c9fac1dac8 100644 --- a/clippy_lints/src/utils/hir_utils.rs +++ b/clippy_lints/src/utils/hir_utils.rs @@ -3,7 +3,7 @@ use crate::utils::differing_macro_contexts; use rustc::hir::ptr::P; use rustc::hir::*; use rustc::lint::LateContext; -use rustc::ty::{self, TypeckTables}; +use rustc::ty::TypeckTables; use std::collections::hash_map::DefaultHasher; use std::hash::{Hash, Hasher}; use syntax::ast::Name; @@ -439,8 +439,6 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> { self.hash_exprs(args); }, ExprKind::Cast(ref e, ref ty) => { - let c: fn(_, _) -> _ = ExprKind::Cast; - c.hash(&mut self.s); self.hash_expr(e); self.hash_ty(ty); }, From cac69ec063e9fcb26e0f3102c82b9cb2d56350fe Mon Sep 17 00:00:00 2001 From: xd009642 Date: Sat, 27 Jul 2019 11:51:27 +0100 Subject: [PATCH 06/13] Respond to comments and improve printout Now get the trait names for the diagnostic message and removed more `let c: fn(_) -> _ = T; hashes from hir_utils --- clippy_lints/src/trait_bounds.rs | 10 ++++++++-- clippy_lints/src/utils/hir_utils.rs | 6 ------ 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs index cb836eac3a6f1..3ef353a978fae 100644 --- a/clippy_lints/src/trait_bounds.rs +++ b/clippy_lints/src/trait_bounds.rs @@ -32,10 +32,16 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TraitBounds { if let Some(ref v) = map.insert(h, p.bounds.iter().collect::>()) { let mut hint_string = format!("consider combining the bounds: `{:?}: ", p.bounded_ty); for b in v.iter() { - hint_string.push_str(&format!("{:?}, ", b)); + if let GenericBound::Trait(ref poly_trait_ref, _) = b { + let path = &poly_trait_ref.trait_ref.path; + hint_string.push_str(&format!("{}, ", path)); + } } for b in p.bounds.iter() { - hint_string.push_str(&format!("{:?}, ", b)); + if let GenericBound::Trait(ref poly_trait_ref, _) = b { + let path = &poly_trait_ref.trait_ref.path; + hint_string.push_str(&format!("{}, ", path)); + } } hint_string.truncate(hint_string.len() - 2); hint_string.push('`'); diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs index 703c9fac1dac8..449b8c4397da7 100644 --- a/clippy_lints/src/utils/hir_utils.rs +++ b/clippy_lints/src/utils/hir_utils.rs @@ -513,18 +513,12 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> { } }, ExprKind::Tup(ref tup) => { - let c: fn(_) -> _ = ExprKind::Tup; - c.hash(&mut self.s); self.hash_exprs(tup); }, ExprKind::Array(ref v) => { - let c: fn(_) -> _ = ExprKind::Array; - c.hash(&mut self.s); self.hash_exprs(v); }, ExprKind::Type(ref e, ref ty) => { - let c: fn(_, _) -> _ = ExprKind::Type; - c.hash(&mut self.s); self.hash_expr(e); self.hash_ty(ty); }, From 5e9906b2c64c07e95252e91a4ce1534cfa4cf10b Mon Sep 17 00:00:00 2001 From: xd009642 Date: Sat, 27 Jul 2019 12:06:25 +0100 Subject: [PATCH 07/13] Added doc comment fixed type printout Added a doc comment for the lint and fixed the printout of the type so it prints T not type(T) --- clippy_lints/src/trait_bounds.rs | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-) diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs index 3ef353a978fae..f5ca3793dbc04 100644 --- a/clippy_lints/src/trait_bounds.rs +++ b/clippy_lints/src/trait_bounds.rs @@ -1,4 +1,4 @@ -use crate::utils::{in_macro, span_help_and_lint, SpanlessHash}; +use crate::utils::{in_macro, snippet, span_help_and_lint, SpanlessHash}; use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; use rustc::{declare_tool_lint, impl_lint_pass}; use rustc_data_structures::fx::FxHashMap; @@ -8,6 +8,20 @@ use rustc::hir::*; pub struct TraitBounds; declare_clippy_lint! { + /// **What it does:** This lint warns about unnecessary type repetitions in trait bounds + /// + /// **Why is this bad?** Complexity + /// + /// **Example:** + /// ```rust + /// pub fn foo(t: T) where T: Copy, T: Clone + /// ``` + /// + /// Could be written as: + /// + /// ```rust + /// pub fn foo(t: T) where T: Copy + Clone + /// ``` pub TYPE_REPETITION_IN_BOUNDS, complexity, "Types are repeated unnecessary in trait bounds use `+` instead of using `T: _, T: _`" @@ -30,7 +44,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TraitBounds { if let WherePredicate::BoundPredicate(ref p) = bound { let h = hash(&p.bounded_ty); if let Some(ref v) = map.insert(h, p.bounds.iter().collect::>()) { - let mut hint_string = format!("consider combining the bounds: `{:?}: ", p.bounded_ty); + let mut hint_string = format!("consider combining the bounds: `{}: ", snippet(cx, p.bounded_ty.span, "_")); for b in v.iter() { if let GenericBound::Trait(ref poly_trait_ref, _) = b { let path = &poly_trait_ref.trait_ref.path; From c962ddbd29ed5b374c55a0fba43cf3d0af9ad680 Mon Sep 17 00:00:00 2001 From: xd009642 Date: Sat, 27 Jul 2019 12:07:02 +0100 Subject: [PATCH 08/13] Updated test stderr --- tests/ui/type_repetition_in_bounds.stderr | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/ui/type_repetition_in_bounds.stderr b/tests/ui/type_repetition_in_bounds.stderr index 1b49c69533ce5..6f5c67afb73bb 100644 --- a/tests/ui/type_repetition_in_bounds.stderr +++ b/tests/ui/type_repetition_in_bounds.stderr @@ -9,7 +9,7 @@ note: lint level defined here | LL | #[deny(clippy::type_repetition_in_bounds)] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - = help: consider combining the bounds: `T: Copy + Clone` + = help: consider combining the bounds: `T: Copy, Clone` error: aborting due to previous error From 925e8207fa8ff6cc4aea7337b6cb3eeb318123d3 Mon Sep 17 00:00:00 2001 From: xd009642 Date: Sat, 27 Jul 2019 21:58:29 +0100 Subject: [PATCH 09/13] Respond to review comments Update README and CHANGELOG using the util scripts, refine the help message and fix the float_cmp error. --- CHANGELOG.md | 1 + README.md | 2 +- clippy_lints/src/lib.rs | 5 +++-- clippy_lints/src/trait_bounds.rs | 18 +++++++++------- clippy_lints/src/utils/hir_utils.rs | 30 +++++++++++---------------- src/lintlist/mod.rs | 9 +++++++- tests/ui/float_cmp.stderr | 11 +++++++++- tests/ui/type_repetition_in_bounds.rs | 17 +++++++++------ 8 files changed, 57 insertions(+), 36 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index ff5aebbc892ba..089897811a595 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1138,6 +1138,7 @@ Released 2018-09-13 [`trivially_copy_pass_by_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref [`try_err`]: https://rust-lang.github.io/rust-clippy/master/index.html#try_err [`type_complexity`]: https://rust-lang.github.io/rust-clippy/master/index.html#type_complexity +[`type_repetition_in_bounds`]: https://rust-lang.github.io/rust-clippy/master/index.html#type_repetition_in_bounds [`unicode_not_nfc`]: https://rust-lang.github.io/rust-clippy/master/index.html#unicode_not_nfc [`unimplemented`]: https://rust-lang.github.io/rust-clippy/master/index.html#unimplemented [`unit_arg`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg diff --git a/README.md b/README.md index 1e649d8982fe2..38651f72eb366 100644 --- a/README.md +++ b/README.md @@ -6,7 +6,7 @@ A collection of lints to catch common mistakes and improve your [Rust](https://github.com/rust-lang/rust) code. -[There are 308 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html) +[There are 309 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html) We have a bunch of lint categories to allow you to choose how much Clippy is supposed to ~~annoy~~ help you: diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs index faffb1a67f1a2..908bbeb5e19fb 100644 --- a/clippy_lints/src/lib.rs +++ b/clippy_lints/src/lib.rs @@ -263,9 +263,9 @@ pub mod strings; pub mod suspicious_trait_impl; pub mod swap; pub mod temporary_assignment; +pub mod trait_bounds; pub mod transmute; pub mod transmuting_null; -pub mod trait_bounds; pub mod trivially_copy_pass_by_ref; pub mod try_err; pub mod types; @@ -860,6 +860,7 @@ pub fn register_plugins(reg: &mut rustc_plugin::Registry<'_>, conf: &Conf) { swap::ALMOST_SWAPPED, swap::MANUAL_SWAP, temporary_assignment::TEMPORARY_ASSIGNMENT, + trait_bounds::TYPE_REPETITION_IN_BOUNDS, transmute::CROSSPOINTER_TRANSMUTE, transmute::TRANSMUTE_BYTES_TO_STR, transmute::TRANSMUTE_INT_TO_BOOL, @@ -870,7 +871,6 @@ pub fn register_plugins(reg: &mut rustc_plugin::Registry<'_>, conf: &Conf) { transmute::USELESS_TRANSMUTE, transmute::WRONG_TRANSMUTE, transmuting_null::TRANSMUTING_NULL, - trait_bounds::TYPE_REPETITION_IN_BOUNDS, trivially_copy_pass_by_ref::TRIVIALLY_COPY_PASS_BY_REF, try_err::TRY_ERR, types::ABSURD_EXTREME_COMPARISONS, @@ -1042,6 +1042,7 @@ pub fn register_plugins(reg: &mut rustc_plugin::Registry<'_>, conf: &Conf) { reference::REF_IN_DEREF, swap::MANUAL_SWAP, temporary_assignment::TEMPORARY_ASSIGNMENT, + trait_bounds::TYPE_REPETITION_IN_BOUNDS, transmute::CROSSPOINTER_TRANSMUTE, transmute::TRANSMUTE_BYTES_TO_STR, transmute::TRANSMUTE_INT_TO_BOOL, diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs index f5ca3793dbc04..8a719c0dd041b 100644 --- a/clippy_lints/src/trait_bounds.rs +++ b/clippy_lints/src/trait_bounds.rs @@ -1,8 +1,8 @@ use crate::utils::{in_macro, snippet, span_help_and_lint, SpanlessHash}; +use rustc::hir::*; use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; use rustc::{declare_tool_lint, impl_lint_pass}; use rustc_data_structures::fx::FxHashMap; -use rustc::hir::*; #[derive(Copy, Clone)] pub struct TraitBounds; @@ -10,11 +10,12 @@ pub struct TraitBounds; declare_clippy_lint! { /// **What it does:** This lint warns about unnecessary type repetitions in trait bounds /// - /// **Why is this bad?** Complexity + /// **Why is this bad?** Repeating the type for every bound makes the code + /// less readable than combining the bounds /// /// **Example:** /// ```rust - /// pub fn foo(t: T) where T: Copy, T: Clone + /// pub fn foo(t: T) where T: Copy, T: Clone /// ``` /// /// Could be written as: @@ -34,7 +35,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TraitBounds { if in_macro(gen.span) { return; } - let hash = | ty | -> u64 { + let hash = |ty| -> u64 { let mut hasher = SpanlessHash::new(cx, cx.tables); hasher.hash_ty(ty); hasher.finish() @@ -44,17 +45,20 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TraitBounds { if let WherePredicate::BoundPredicate(ref p) = bound { let h = hash(&p.bounded_ty); if let Some(ref v) = map.insert(h, p.bounds.iter().collect::>()) { - let mut hint_string = format!("consider combining the bounds: `{}: ", snippet(cx, p.bounded_ty.span, "_")); + let mut hint_string = format!( + "consider combining the bounds: `{}:", + snippet(cx, p.bounded_ty.span, "_") + ); for b in v.iter() { if let GenericBound::Trait(ref poly_trait_ref, _) = b { let path = &poly_trait_ref.trait_ref.path; - hint_string.push_str(&format!("{}, ", path)); + hint_string.push_str(&format!(" {} +", path)); } } for b in p.bounds.iter() { if let GenericBound::Trait(ref poly_trait_ref, _) = b { let path = &poly_trait_ref.trait_ref.path; - hint_string.push_str(&format!("{}, ", path)); + hint_string.push_str(&format!(" {} +", path)); } } hint_string.truncate(hint_string.len() - 2); diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs index 449b8c4397da7..db7b10c6bacd9 100644 --- a/clippy_lints/src/utils/hir_utils.rs +++ b/clippy_lints/src/utils/hir_utils.rs @@ -639,23 +639,20 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> { for ty in ty_list { self.hash_ty(ty); } - }, - TyKind::Path(qpath) => { - match qpath { - QPath::Resolved(ref maybe_ty, ref path) => { - if let Some(ref ty) = maybe_ty { - self.hash_ty(ty); - } - for segment in &path.segments { - segment.ident.name.hash(&mut self.s); - } - }, - QPath::TypeRelative(ref ty, ref segment) => { + TyKind::Path(qpath) => match qpath { + QPath::Resolved(ref maybe_ty, ref path) => { + if let Some(ref ty) = maybe_ty { self.hash_ty(ty); + } + for segment in &path.segments { segment.ident.name.hash(&mut self.s); - }, - } + } + }, + QPath::TypeRelative(ref ty, ref segment) => { + self.hash_ty(ty); + segment.ident.name.hash(&mut self.s); + }, }, TyKind::Def(_, arg_list) => { for arg in arg_list { @@ -670,14 +667,11 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> { }, TyKind::TraitObject(_, lifetime) => { self.hash_lifetime(lifetime); - }, TyKind::Typeof(anon_const) => { self.hash_expr(&self.cx.tcx.hir().body(anon_const.body).value); }, - TyKind::CVarArgs(lifetime) => { - self.hash_lifetime(lifetime) - }, + TyKind::CVarArgs(lifetime) => self.hash_lifetime(lifetime), TyKind::Err | TyKind::Infer | TyKind::Never => {}, } } diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs index 2d9e800b6e432..49bce5a6cef4d 100644 --- a/src/lintlist/mod.rs +++ b/src/lintlist/mod.rs @@ -6,7 +6,7 @@ pub use lint::Lint; pub use lint::LINT_LEVELS; // begin lint list, do not remove this comment, it’s used in `update_lints` -pub const ALL_LINTS: [Lint; 308] = [ +pub const ALL_LINTS: [Lint; 309] = [ Lint { name: "absurd_extreme_comparisons", group: "correctness", @@ -1848,6 +1848,13 @@ pub const ALL_LINTS: [Lint; 308] = [ deprecation: None, module: "types", }, + Lint { + name: "type_repetition_in_bounds", + group: "complexity", + desc: "Types are repeated unnecessary in trait bounds use `+` instead of using `T: _, T: _`", + deprecation: None, + module: "trait_bounds", + }, Lint { name: "unicode_not_nfc", group: "pedantic", diff --git a/tests/ui/float_cmp.stderr b/tests/ui/float_cmp.stderr index 5dc5fbf0f6e8a..d1ffc0d15c722 100644 --- a/tests/ui/float_cmp.stderr +++ b/tests/ui/float_cmp.stderr @@ -1,3 +1,12 @@ +error: this type has already been used as a bound predicate + --> $DIR/float_cmp.rs:12:5 + | +LL | T: Copy, + | ^^^^^^^ + | + = note: `-D clippy::type-repetition-in-bounds` implied by `-D warnings` + = help: consider combining the bounds: `T: Add, Copy` + error: strict comparison of f32 or f64 --> $DIR/float_cmp.rs:60:5 | @@ -35,5 +44,5 @@ note: std::f32::EPSILON and std::f64::EPSILON are available. LL | twice(x) != twice(ONE as f64); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -error: aborting due to 3 previous errors +error: aborting due to 4 previous errors diff --git a/tests/ui/type_repetition_in_bounds.rs b/tests/ui/type_repetition_in_bounds.rs index 3aa0d0da56170..8b538be762b0c 100644 --- a/tests/ui/type_repetition_in_bounds.rs +++ b/tests/ui/type_repetition_in_bounds.rs @@ -1,14 +1,19 @@ #[deny(clippy::type_repetition_in_bounds)] -pub fn foo(_t: T) where T: Copy, T: Clone { +pub fn foo(_t: T) +where + T: Copy, + T: Clone, +{ unimplemented!(); } -pub fn bar(_t: T, _u: U) where T: Copy, U: Clone { +pub fn bar(_t: T, _u: U) +where + T: Copy, + U: Clone, +{ unimplemented!(); } - -fn main() { - -} +fn main() {} From bba2c7f02c3b49ce3f4d5f83f66b52dca5bd310b Mon Sep 17 00:00:00 2001 From: xd009642 Date: Sat, 27 Jul 2019 22:53:26 +0100 Subject: [PATCH 10/13] Updated tests. Removed unnecessary type repetition in float test and regenerated stderr Regenerated type_repetition stderr --- tests/ui/float_cmp.rs | 3 +-- tests/ui/float_cmp.stderr | 23 +++++++---------------- tests/ui/type_repetition_in_bounds.stderr | 8 ++++---- 3 files changed, 12 insertions(+), 22 deletions(-) diff --git a/tests/ui/float_cmp.rs b/tests/ui/float_cmp.rs index 1ec8af3e38719..207c1bcbbc676 100644 --- a/tests/ui/float_cmp.rs +++ b/tests/ui/float_cmp.rs @@ -8,8 +8,7 @@ const ONE: f32 = ZERO + 1.0; fn twice(x: T) -> T where - T: Add, - T: Copy, + T: Add + Copy, { x + x } diff --git a/tests/ui/float_cmp.stderr b/tests/ui/float_cmp.stderr index d1ffc0d15c722..116e3e90e6372 100644 --- a/tests/ui/float_cmp.stderr +++ b/tests/ui/float_cmp.stderr @@ -1,48 +1,39 @@ -error: this type has already been used as a bound predicate - --> $DIR/float_cmp.rs:12:5 - | -LL | T: Copy, - | ^^^^^^^ - | - = note: `-D clippy::type-repetition-in-bounds` implied by `-D warnings` - = help: consider combining the bounds: `T: Add, Copy` - error: strict comparison of f32 or f64 - --> $DIR/float_cmp.rs:60:5 + --> $DIR/float_cmp.rs:59:5 | LL | ONE as f64 != 2.0; | ^^^^^^^^^^^^^^^^^ help: consider comparing them within some error: `(ONE as f64 - 2.0).abs() > error` | = note: `-D clippy::float-cmp` implied by `-D warnings` note: std::f32::EPSILON and std::f64::EPSILON are available. - --> $DIR/float_cmp.rs:60:5 + --> $DIR/float_cmp.rs:59:5 | LL | ONE as f64 != 2.0; | ^^^^^^^^^^^^^^^^^ error: strict comparison of f32 or f64 - --> $DIR/float_cmp.rs:65:5 + --> $DIR/float_cmp.rs:64:5 | LL | x == 1.0; | ^^^^^^^^ help: consider comparing them within some error: `(x - 1.0).abs() < error` | note: std::f32::EPSILON and std::f64::EPSILON are available. - --> $DIR/float_cmp.rs:65:5 + --> $DIR/float_cmp.rs:64:5 | LL | x == 1.0; | ^^^^^^^^ error: strict comparison of f32 or f64 - --> $DIR/float_cmp.rs:68:5 + --> $DIR/float_cmp.rs:67:5 | LL | twice(x) != twice(ONE as f64); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider comparing them within some error: `(twice(x) - twice(ONE as f64)).abs() > error` | note: std::f32::EPSILON and std::f64::EPSILON are available. - --> $DIR/float_cmp.rs:68:5 + --> $DIR/float_cmp.rs:67:5 | LL | twice(x) != twice(ONE as f64); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -error: aborting due to 4 previous errors +error: aborting due to 3 previous errors diff --git a/tests/ui/type_repetition_in_bounds.stderr b/tests/ui/type_repetition_in_bounds.stderr index 6f5c67afb73bb..a72f512b0129a 100644 --- a/tests/ui/type_repetition_in_bounds.stderr +++ b/tests/ui/type_repetition_in_bounds.stderr @@ -1,15 +1,15 @@ error: this type has already been used as a bound predicate - --> $DIR/type_repetition_in_bounds.rs:3:37 + --> $DIR/type_repetition_in_bounds.rs:6:5 | -LL | pub fn foo(_t: T) where T: Copy, T: Clone { - | ^^^^^^^^ +LL | T: Clone, + | ^^^^^^^^ | note: lint level defined here --> $DIR/type_repetition_in_bounds.rs:1:8 | LL | #[deny(clippy::type_repetition_in_bounds)] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - = help: consider combining the bounds: `T: Copy, Clone` + = help: consider combining the bounds: `T: Copy + Clone` error: aborting due to previous error From ad637193f0e5b90db1c934f3c637679514f67777 Mon Sep 17 00:00:00 2001 From: xd009642 Date: Sat, 27 Jul 2019 22:59:46 +0100 Subject: [PATCH 11/13] Hash discriminant of Lifetime::Name --- clippy_lints/src/utils/hir_utils.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs index db7b10c6bacd9..64f5f352570be 100644 --- a/clippy_lints/src/utils/hir_utils.rs +++ b/clippy_lints/src/utils/hir_utils.rs @@ -584,6 +584,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> { pub fn hash_lifetime(&mut self, lifetime: &Lifetime) { if let LifetimeName::Param(ref name) = lifetime.name { + std::mem::discriminant(&name).hash(&mut self.s); match name { ParamName::Plain(ref ident) => { ident.name.hash(&mut self.s); @@ -591,7 +592,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> { ParamName::Fresh(ref size) => { size.hash(&mut self.s); }, - _ => {}, + ParamName::Error => {}, } } } From 03c543515ad3c963f801c65da8f8bb6a4e0a35da Mon Sep 17 00:00:00 2001 From: xd009642 Date: Sat, 27 Jul 2019 23:04:36 +0100 Subject: [PATCH 12/13] Hash discriminant of lifetime.name --- clippy_lints/src/utils/hir_utils.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs index 64f5f352570be..e3da8c494ca6c 100644 --- a/clippy_lints/src/utils/hir_utils.rs +++ b/clippy_lints/src/utils/hir_utils.rs @@ -583,6 +583,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> { } pub fn hash_lifetime(&mut self, lifetime: &Lifetime) { + std::mem::discriminant(&lifetime.name).hash(&mut self.s); if let LifetimeName::Param(ref name) = lifetime.name { std::mem::discriminant(&name).hash(&mut self.s); match name { From 78ebcaa5263e0fd4c4ec89da648d8386c034ce84 Mon Sep 17 00:00:00 2001 From: xd009642 Date: Sun, 28 Jul 2019 09:31:05 +0100 Subject: [PATCH 13/13] Fix dogfood test --- clippy_lints/src/utils/hir_utils.rs | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs index e3da8c494ca6c..6fc5939a21602 100644 --- a/clippy_lints/src/utils/hir_utils.rs +++ b/clippy_lints/src/utils/hir_utils.rs @@ -438,7 +438,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> { self.hash_expr(fun); self.hash_exprs(args); }, - ExprKind::Cast(ref e, ref ty) => { + ExprKind::Cast(ref e, ref ty) | ExprKind::Type(ref e, ref ty) => { self.hash_expr(e); self.hash_ty(ty); }, @@ -518,10 +518,6 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> { ExprKind::Array(ref v) => { self.hash_exprs(v); }, - ExprKind::Type(ref e, ref ty) => { - self.hash_expr(e); - self.hash_ty(ty); - }, ExprKind::Unary(lop, ref le) => { lop.hash(&mut self.s); self.hash_expr(le); @@ -585,7 +581,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> { pub fn hash_lifetime(&mut self, lifetime: &Lifetime) { std::mem::discriminant(&lifetime.name).hash(&mut self.s); if let LifetimeName::Param(ref name) = lifetime.name { - std::mem::discriminant(&name).hash(&mut self.s); + std::mem::discriminant(name).hash(&mut self.s); match name { ParamName::Plain(ref ident) => { ident.name.hash(&mut self.s); @@ -603,7 +599,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> { } pub fn hash_tykind(&mut self, ty: &TyKind) { - std::mem::discriminant(&ty).hash(&mut self.s); + std::mem::discriminant(ty).hash(&mut self.s); match ty { TyKind::Slice(ty) => { self.hash_ty(ty);