Auto merge of #4809 - iankronquist:patch-1, r=flip1995

[rust.git] / clippy_lints / src / eta_reduction.rs

diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 485a29ed3d89c80e77874965065a7278ee493a0b..5ef933845005c503833ea219f518229ec271bd39 100644 (file)
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -1,10 +1,11 @@
 use if_chain::if_chain;
 use matches::matches;
-use rustc::hir::*;
-use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass};
+use rustc::lint::in_external_macro;
 use rustc::ty::{self, Ty};
-use rustc::{declare_lint_pass, declare_tool_lint};
 use rustc_errors::Applicability;
+use rustc_hir::*;
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 use crate::utils::{
     implements_trait, is_adjusted, iter_input_pats, snippet_opt, span_lint_and_then, type_is_unsafe_function,
@@ -60,13 +61,13 @@
 declare_lint_pass!(EtaReduction => [REDUNDANT_CLOSURE, REDUNDANT_CLOSURE_FOR_METHOD_CALLS]);
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EtaReduction {
-    fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
+    fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr<'_>) {
         if in_external_macro(cx.sess(), expr.span) {
             return;
         }
 
-        match expr.node {
-            ExprKind::Call(_, ref args) | ExprKind::MethodCall(_, _, ref args) => {
+        match expr.kind {
+            ExprKind::Call(_, args) | ExprKind::MethodCall(_, _, args) => {
                 for arg in args {
                     check_closure(cx, arg)
                 }
@@ -76,15 +77,15 @@ fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
     }
 }
 
-fn check_closure(cx: &LateContext<'_, '_>, expr: &Expr) {
-    if let ExprKind::Closure(_, ref decl, eid, _, _) = expr.node {
+fn check_closure(cx: &LateContext<'_, '_>, expr: &Expr<'_>) {
+    if let ExprKind::Closure(_, ref decl, eid, _, _) = expr.kind {
         let body = cx.tcx.hir().body(eid);
         let ex = &body.value;
 
         if_chain!(
-            if let ExprKind::Call(ref caller, ref args) = ex.node;
+            if let ExprKind::Call(ref caller, ref args) = ex.kind;
 
-            if let ExprKind::Path(_) = caller.node;
+            if let ExprKind::Path(_) = caller.kind;
 
             // Not the same number of arguments, there is no way the closure is the same as the function return;
             if args.len() == decl.inputs.len();
@@ -94,11 +95,11 @@ fn check_closure(cx: &LateContext<'_, '_>, expr: &Expr) {
 
             let fn_ty = cx.tables.expr_ty(caller);
 
-            if matches!(fn_ty.sty, ty::FnDef(_, _) | ty::FnPtr(_) | ty::Closure(_, _));
+            if matches!(fn_ty.kind, ty::FnDef(_, _) | ty::FnPtr(_) | ty::Closure(_, _));
 
             if !type_is_unsafe_function(cx, fn_ty);
 
-            if compare_inputs(&mut iter_input_pats(decl, body), &mut args.into_iter());
+            if compare_inputs(&mut iter_input_pats(decl, body), &mut args.iter());
 
             then {
                 span_lint_and_then(cx, REDUNDANT_CLOSURE, expr.span, "redundant closure found", |db| {
@@ -115,7 +116,7 @@ fn check_closure(cx: &LateContext<'_, '_>, expr: &Expr) {
         );
 
         if_chain!(
-            if let ExprKind::MethodCall(ref path, _, ref args) = ex.node;
+            if let ExprKind::MethodCall(ref path, _, ref args) = ex.kind;
 
             // Not the same number of arguments, there is no way the closure is the same as the function return;
             if args.len() == decl.inputs.len();
@@ -126,7 +127,7 @@ fn check_closure(cx: &LateContext<'_, '_>, expr: &Expr) {
             let method_def_id = cx.tables.type_dependent_def_id(ex.hir_id).unwrap();
             if !type_is_unsafe_function(cx, cx.tcx.type_of(method_def_id));
 
-            if compare_inputs(&mut iter_input_pats(decl, body), &mut args.into_iter());
+            if compare_inputs(&mut iter_input_pats(decl, body), &mut args.iter());
 
             if let Some(name) = get_ufcs_type_name(cx, method_def_id, &args[0]);
 
@@ -145,11 +146,7 @@ fn check_closure(cx: &LateContext<'_, '_>, expr: &Expr) {
 }
 
 /// Tries to determine the type for universal function call to be used instead of the closure
-fn get_ufcs_type_name(
-    cx: &LateContext<'_, '_>,
-    method_def_id: def_id::DefId,
-    self_arg: &Expr,
-) -> std::option::Option<String> {
+fn get_ufcs_type_name(cx: &LateContext<'_, '_>, method_def_id: def_id::DefId, self_arg: &Expr<'_>) -> Option<String> {
     let expected_type_of_self = &cx.tcx.fn_sig(method_def_id).inputs_and_output().skip_binder()[0];
     let actual_type_of_self = &cx.tables.node_type(self_arg.hir_id);
 
@@ -171,7 +168,7 @@ fn get_ufcs_type_name(
 }
 
 fn match_borrow_depth(lhs: Ty<'_>, rhs: Ty<'_>) -> bool {
-    match (&lhs.sty, &rhs.sty) {
+    match (&lhs.kind, &rhs.kind) {
         (ty::Ref(_, t1, mut1), ty::Ref(_, t2, mut2)) => mut1 == mut2 && match_borrow_depth(&t1, &t2),
         (l, r) => match (l, r) {
             (ty::Ref(_, _, _), _) | (_, ty::Ref(_, _, _)) => false,
@@ -181,7 +178,7 @@ fn match_borrow_depth(lhs: Ty<'_>, rhs: Ty<'_>) -> bool {
 }
 
 fn match_types(lhs: Ty<'_>, rhs: Ty<'_>) -> bool {
-    match (&lhs.sty, &rhs.sty) {
+    match (&lhs.kind, &rhs.kind) {
         (ty::Bool, ty::Bool)
         | (ty::Char, ty::Char)
         | (ty::Int(_), ty::Int(_))
@@ -195,7 +192,7 @@ fn match_types(lhs: Ty<'_>, rhs: Ty<'_>) -> bool {
 }
 
 fn get_type_name(cx: &LateContext<'_, '_>, ty: Ty<'_>) -> String {
-    match ty.sty {
+    match ty.kind {
         ty::Adt(t, _) => cx.tcx.def_path_str(t.did),
         ty::Ref(_, r, _) => get_type_name(cx, &r),
         _ => ty.to_string(),
@@ -203,13 +200,13 @@ fn get_type_name(cx: &LateContext<'_, '_>, ty: Ty<'_>) -> String {
 }
 
 fn compare_inputs(
-    closure_inputs: &mut dyn Iterator<Item = &Param>,
-    call_args: &mut dyn Iterator<Item = &Expr>,
+    closure_inputs: &mut dyn Iterator<Item = &Param<'_>>,
+    call_args: &mut dyn Iterator<Item = &Expr<'_>>,
 ) -> bool {
     for (closure_input, function_arg) in closure_inputs.zip(call_args) {
-        if let PatKind::Binding(_, _, ident, _) = closure_input.pat.node {
+        if let PatKind::Binding(_, _, ident, _) = closure_input.pat.kind {
             // XXXManishearth Should I be checking the binding mode here?
-            if let ExprKind::Path(QPath::Resolved(None, ref p)) = function_arg.node {
+            if let ExprKind::Path(QPath::Resolved(None, ref p)) = function_arg.kind {
                 if p.segments.len() != 1 {
                     // If it's a proper path, it can't be a local variable
                     return false;