update to the rust-PR that unblocks clippy

Author: oli-obk

clippy_lints/src/approx_const.rs

@@ -59,8 +59,8 @@ impl LintPass for Pass {
     }
 }
 
-impl LateLintPass for Pass {
-    fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) {
+impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
+    fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) {
         if let ExprLit(ref lit) = e.node {
             check_lit(cx, lit, e);
         }

clippy_lints/src/arithmetic.rs

@@ -47,8 +47,8 @@ impl LintPass for Arithmetic {
     }
 }
 
-impl LateLintPass for Arithmetic {
-    fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) {
+impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Arithmetic {
+    fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) {
         if self.span.is_some() {
             return;
         }
@@ -82,7 +82,7 @@ impl LateLintPass for Arithmetic {
         }
     }
 
-    fn check_expr_post<'a, 'tcx: 'a>(&mut self, _: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) {
+    fn check_expr_post(&mut self, _: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) {
         if Some(expr.span) == self.span {
             self.span = None;
         }

clippy_lints/src/array_indexing.rs

@@ -55,8 +55,8 @@ impl LintPass for ArrayIndexing {
     }
 }
 
-impl LateLintPass for ArrayIndexing {
-    fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx hir::Expr) {
+impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ArrayIndexing {
+    fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx hir::Expr) {
         if let hir::ExprIndex(ref array, ref index) = e.node {
             // Array with known size can be checked statically
             let ty = cx.tcx.tables().expr_ty(array);

clippy_lints/src/assign_ops.rs

@@ -66,8 +66,8 @@ impl LintPass for AssignOps {
     }
 }
 
-impl LateLintPass for AssignOps {
-    fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) {
+impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps {
+    fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) {
         match expr.node {
             hir::ExprAssignOp(op, ref lhs, ref rhs) => {
                 span_lint_and_then(cx, ASSIGN_OPS, expr.span, "assign operation detected", |db| {

clippy_lints/src/attrs.rs

@@ -81,8 +81,8 @@ impl LintPass for AttrPass {
     }
 }
 
-impl LateLintPass for AttrPass {
-    fn check_attribute<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, attr: &'tcx Attribute) {
+impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AttrPass {
+    fn check_attribute(&mut self, cx: &LateContext<'a, 'tcx>, attr: &'tcx Attribute) {
         if let MetaItemKind::List(ref items) = attr.value.node {
             if items.is_empty() || attr.name() != "deprecated" {
                 return;
@@ -99,7 +99,7 @@ impl LateLintPass for AttrPass {
         }
     }
 
-    fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) {
+    fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) {
         if is_relevant_item(cx, item) {
             check_attrs(cx, item.span, &item.name, &item.attrs)
         }
@@ -138,13 +138,13 @@ impl LateLintPass for AttrPass {
         }
     }
 
-    fn check_impl_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx ImplItem) {
+    fn check_impl_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx ImplItem) {
         if is_relevant_impl(cx, item) {
             check_attrs(cx, item.span, &item.name, &item.attrs)
         }
     }
 
-    fn check_trait_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx TraitItem) {
+    fn check_trait_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx TraitItem) {
         if is_relevant_trait(cx, item) {
             check_attrs(cx, item.span, &item.name, &item.attrs)
         }

clippy_lints/src/bit_mask.rs

@@ -79,8 +79,8 @@ impl LintPass for BitMask {
     }
 }
 
-impl LateLintPass for BitMask {
-    fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) {
+impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BitMask {
+    fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) {
         if let ExprBinary(ref cmp, ref left, ref right) = e.node {
             if cmp.node.is_comparison() {
                 if let Some(cmp_opt) = fetch_int_literal(cx, right) {

clippy_lints/src/blacklisted_name.rs

@@ -37,8 +37,8 @@ impl LintPass for BlackListedName {
     }
 }
 
-impl LateLintPass for BlackListedName {
-    fn check_pat<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, pat: &'tcx Pat) {
+impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BlackListedName {
+    fn check_pat(&mut self, cx: &LateContext<'a, 'tcx>, pat: &'tcx Pat) {
         if let PatKind::Binding(_, _, ref ident, _) = pat.node {
             if self.blacklist.iter().any(|s| s == &*ident.node.as_str()) {
                 span_lint(cx,

clippy_lints/src/block_in_if_condition.rs

@@ -74,8 +74,8 @@ const BRACED_EXPR_MESSAGE: &'static str = "omit braces around single expression
 const COMPLEX_BLOCK_MESSAGE: &'static str = "in an 'if' condition, avoid complex blocks or closures with blocks; \
                                              instead, move the block or closure higher and bind it with a 'let'";
 
-impl LateLintPass for BlockInIfCondition {
-    fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
+impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BlockInIfCondition {
+    fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
         if let ExprIf(ref check, ref then, _) = expr.node {
             if let ExprBlock(ref block) = check.node {
                 if block.rules == DefaultBlock {

clippy_lints/src/booleans.rs

@@ -53,8 +53,8 @@ impl LintPass for NonminimalBool {
     }
 }
 
-impl LateLintPass for NonminimalBool {
-    fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) {
+impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonminimalBool {
+    fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) {
         NonminimalBoolVisitor { cx: cx }.visit_item(item)
     }
 }

clippy_lints/src/copies.rs

@@ -109,8 +109,8 @@ impl LintPass for CopyAndPaste {
     }
 }
 
-impl LateLintPass for CopyAndPaste {
-    fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
+impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CopyAndPaste {
+    fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
         if !in_macro(cx, expr.span) {
             // skip ifs directly in else, it will be checked in the parent if
             if let Some(&Expr { node: ExprIf(_, _, Some(ref else_expr)), .. }) = get_parent_expr(cx, expr) {