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

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

diff --git a/clippy_lints/src/mutable_debug_assertion.rs b/clippy_lints/src/mutable_debug_assertion.rs
index 6d955331add27d552296112c2cb422f7f07f627f..f0c5c95b1d49951655fde2b8ebf187267ec96e74 100644 (file)
--- a/clippy_lints/src/mutable_debug_assertion.rs
+++ b/clippy_lints/src/mutable_debug_assertion.rs
@@ -1,11 +1,13 @@
 use crate::utils::{is_direct_expn_of, span_lint};
 use if_chain::if_chain;
 use matches::matches;
-use rustc::hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
-use rustc::hir::{Expr, ExprKind, Mutability, StmtKind, UnOp};
-use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
-use rustc::{declare_lint_pass, declare_tool_lint, ty};
-use syntax_pos::Span;
+use rustc::hir::map::Map;
+use rustc::ty;
+use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
+use rustc_hir::{BorrowKind, Expr, ExprKind, MatchSource, Mutability, StmtKind, UnOp};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::Span;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for function/method calls with a mutable
@@ -26,7 +28,7 @@
     /// debug_assert!(take_a_mut_parameter(&mut 5));
     /// ```
     pub DEBUG_ASSERT_WITH_MUT_CALL,
-    correctness,
+    nursery,
     "mutable arguments in `debug_assert{,_ne,_eq}!`"
 }
 
@@ -35,7 +37,7 @@
 const DEBUG_MACRO_NAMES: [&str; 3] = ["debug_assert", "debug_assert_eq", "debug_assert_ne"];
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for DebugAssertWithMutCall {
-    fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) {
+    fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr<'_>) {
         for dmn in &DEBUG_MACRO_NAMES {
             if is_direct_expn_of(e.span, dmn).is_some() {
                 if let Some(span) = extract_call(cx, e) {
@@ -53,44 +55,44 @@ fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) {
 
 //HACK(hellow554): remove this when #4694 is implemented
 #[allow(clippy::cognitive_complexity)]
-fn extract_call<'a, 'tcx>(cx: &'a LateContext<'a, 'tcx>, e: &'tcx Expr) -> Option<Span> {
+fn extract_call<'a, 'tcx>(cx: &'a LateContext<'a, 'tcx>, e: &'tcx Expr<'_>) -> Option<Span> {
     if_chain! {
         if let ExprKind::Block(ref block, _) = e.kind;
         if block.stmts.len() == 1;
         if let StmtKind::Semi(ref matchexpr) = block.stmts[0].kind;
         then {
+            // debug_assert
             if_chain! {
                 if let ExprKind::Match(ref ifclause, _, _) = matchexpr.kind;
                 if let ExprKind::DropTemps(ref droptmp) = ifclause.kind;
                 if let ExprKind::Unary(UnOp::UnNot, ref condition) = droptmp.kind;
                 then {
-                    // debug_assert
                     let mut visitor = MutArgVisitor::new(cx);
                     visitor.visit_expr(condition);
                     return visitor.expr_span();
-                } else {
-                    // debug_assert_{eq,ne}
-                    if_chain! {
-                        if let ExprKind::Block(ref matchblock, _) = matchexpr.kind;
-                        if let Some(ref matchheader) = matchblock.expr;
-                        if let ExprKind::Match(ref headerexpr, _, _) = matchheader.kind;
-                        if let ExprKind::Tup(ref conditions) = headerexpr.kind;
-                        if conditions.len() == 2;
-                        then {
-                            if let ExprKind::AddrOf(_, ref lhs) = conditions[0].kind {
-                                let mut visitor = MutArgVisitor::new(cx);
-                                visitor.visit_expr(lhs);
-                                if let Some(span) = visitor.expr_span() {
-                                    return Some(span);
-                                }
-                            }
-                            if let ExprKind::AddrOf(_, ref rhs) = conditions[1].kind {
-                                let mut visitor = MutArgVisitor::new(cx);
-                                visitor.visit_expr(rhs);
-                                if let Some(span) = visitor.expr_span() {
-                                    return Some(span);
-                                }
-                            }
+                }
+            }
+
+            // debug_assert_{eq,ne}
+            if_chain! {
+                if let ExprKind::Block(ref matchblock, _) = matchexpr.kind;
+                if let Some(ref matchheader) = matchblock.expr;
+                if let ExprKind::Match(ref headerexpr, _, _) = matchheader.kind;
+                if let ExprKind::Tup(ref conditions) = headerexpr.kind;
+                if conditions.len() == 2;
+                then {
+                    if let ExprKind::AddrOf(BorrowKind::Ref, _, ref lhs) = conditions[0].kind {
+                        let mut visitor = MutArgVisitor::new(cx);
+                        visitor.visit_expr(lhs);
+                        if let Some(span) = visitor.expr_span() {
+                            return Some(span);
+                        }
+                    }
+                    if let ExprKind::AddrOf(BorrowKind::Ref, _, ref rhs) = conditions[1].kind {
+                        let mut visitor = MutArgVisitor::new(cx);
+                        visitor.visit_expr(rhs);
+                        if let Some(span) = visitor.expr_span() {
+                            return Some(span);
                         }
                     }
                 }
@@ -126,9 +128,11 @@ fn expr_span(&self) -> Option<Span> {
 }
 
 impl<'a, 'tcx> Visitor<'tcx> for MutArgVisitor<'a, 'tcx> {
-    fn visit_expr(&mut self, expr: &'tcx Expr) {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
         match expr.kind {
-            ExprKind::AddrOf(Mutability::Mutable, _) => {
+            ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, _) => {
                 self.found = true;
                 return;
             },
@@ -136,20 +140,22 @@ fn visit_expr(&mut self, expr: &'tcx Expr) {
                 if let Some(adj) = self.cx.tables.adjustments().get(expr.hir_id) {
                     if adj
                         .iter()
-                        .any(|a| matches!(a.target.kind, ty::Ref(_, _, Mutability::Mutable)))
+                        .any(|a| matches!(a.target.kind, ty::Ref(_, _, Mutability::Mut)))
                     {
                         self.found = true;
                         return;
                     }
                 }
             },
+            // Don't check await desugars
+            ExprKind::Match(_, _, MatchSource::AwaitDesugar) => return,
             _ if !self.found => self.expr_span = Some(expr.span),
             _ => return,
         }
         walk_expr(self, expr)
     }
 
-    fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<'_, Self::Map> {
         NestedVisitorMap::OnlyBodies(&self.cx.tcx.hir())
     }
 }