add `tcx` to `fn walk`

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

diff --git a/clippy_lints/src/mut_mut.rs b/clippy_lints/src/mut_mut.rs
index 08d979cb5d7a8287e98fa036a746cda677838750..610152a217f1e3dac93028b9b41a945f37b92468 100644 (file)
--- a/clippy_lints/src/mut_mut.rs
+++ b/clippy_lints/src/mut_mut.rs
@@ -1,58 +1,59 @@
-use rustc::hir;
-use rustc::hir::intravisit;
-use rustc::lint::*;
-use rustc::ty::{TypeAndMut, TyRef};
-use utils::{higher, in_external_macro, span_lint};
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::higher;
+use rustc_hir as hir;
+use rustc_hir::intravisit;
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::hir::map::Map;
+use rustc_middle::lint::in_external_macro;
+use rustc_middle::ty;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-/// **What it does:** This lint checks for instances of `mut mut` references.
-///
-/// **Why is this bad?** Multiple `mut`s don't add anything meaningful to the source. This is
-/// either a copy'n'paste error, or it shows a fundamental misunderstanding of references)
-///
-/// **Known problems:** None
-///
-/// **Example:**
-/// ```rust
-/// let x = &mut &mut y;
-/// ```
-declare_lint! {
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for instances of `mut mut` references.
+    ///
+    /// ### Why is this bad?
+    /// Multiple `mut`s don't add anything meaningful to the
+    /// source. This is either a copy'n'paste error, or it shows a fundamental
+    /// misunderstanding of references.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # let mut y = 1;
+    /// let x = &mut &mut y;
+    /// ```
     pub MUT_MUT,
-    Allow,
-    "usage of double-mut refs, e.g. `&mut &mut ...`"
+    pedantic,
+    "usage of double-mut refs, e.g., `&mut &mut ...`"
 }
 
-#[derive(Copy,Clone)]
-pub struct MutMut;
+declare_lint_pass!(MutMut => [MUT_MUT]);
 
-impl LintPass for MutMut {
-    fn get_lints(&self) -> LintArray {
-        lint_array!(MUT_MUT)
-    }
-}
-
-impl LateLintPass for MutMut {
-    fn check_block(&mut self, cx: &LateContext, block: &hir::Block) {
-        intravisit::walk_block(&mut MutVisitor { cx: cx }, block);
+impl<'tcx> LateLintPass<'tcx> for MutMut {
+    fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx hir::Block<'_>) {
+        intravisit::walk_block(&mut MutVisitor { cx }, block);
     }
 
-    fn check_ty(&mut self, cx: &LateContext, ty: &hir::Ty) {
-        use rustc::hir::intravisit::Visitor;
+    fn check_ty(&mut self, cx: &LateContext<'tcx>, ty: &'tcx hir::Ty<'_>) {
+        use rustc_hir::intravisit::Visitor;
 
-        MutVisitor { cx: cx }.visit_ty(ty);
+        MutVisitor { cx }.visit_ty(ty);
     }
 }
 
-pub struct MutVisitor<'a, 'tcx: 'a> {
-    cx: &'a LateContext<'a, 'tcx>,
+pub struct MutVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
 }
 
-impl<'a, 'tcx, 'v> intravisit::Visitor<'v> for MutVisitor<'a, 'tcx> {
-    fn visit_expr(&mut self, expr: &'v hir::Expr) {
-        if in_external_macro(self.cx, expr.span) {
+impl<'a, 'tcx> intravisit::Visitor<'tcx> for MutVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
+        if in_external_macro(self.cx.sess(), expr.span) {
             return;
         }
 
-        if let Some((_, arg, body)) = higher::for_loop(expr) {
+        if let Some(higher::ForLoop { arg, body, .. }) = higher::ForLoop::hir(expr) {
             // A `for` loop lowers to:
             // ```rust
             // match ::std::iter::Iterator::next(&mut iter) {
@@ -61,26 +62,54 @@ fn visit_expr(&mut self, expr: &'v hir::Expr) {
             // Let's ignore the generated code.
             intravisit::walk_expr(self, arg);
             intravisit::walk_expr(self, body);
-        } else if let hir::ExprAddrOf(hir::MutMutable, ref e) = expr.node {
-            if let hir::ExprAddrOf(hir::MutMutable, _) = e.node {
-                span_lint(self.cx, MUT_MUT, expr.span, "generally you want to avoid `&mut &mut _` if possible");
-            } else if let TyRef(_, TypeAndMut { mutbl: hir::MutMutable, .. }) = self.cx.tcx.expr_ty(e).sty {
-                span_lint(self.cx,
-                          MUT_MUT,
-                          expr.span,
-                          "this expression mutably borrows a mutable reference. Consider reborrowing");
+        } else if let hir::ExprKind::AddrOf(hir::BorrowKind::Ref, hir::Mutability::Mut, e) = expr.kind {
+            if let hir::ExprKind::AddrOf(hir::BorrowKind::Ref, hir::Mutability::Mut, _) = e.kind {
+                span_lint(
+                    self.cx,
+                    MUT_MUT,
+                    expr.span,
+                    "generally you want to avoid `&mut &mut _` if possible",
+                );
+            } else if let ty::Ref(_, _, hir::Mutability::Mut) = self.cx.typeck_results().expr_ty(e).kind() {
+                span_lint(
+                    self.cx,
+                    MUT_MUT,
+                    expr.span,
+                    "this expression mutably borrows a mutable reference. Consider reborrowing",
+                );
             }
         }
     }
 
-    fn visit_ty(&mut self, ty: &hir::Ty) {
-        if let hir::TyRptr(_, hir::MutTy { ty: ref pty, mutbl: hir::MutMutable }) = ty.node {
-            if let hir::TyRptr(_, hir::MutTy { mutbl: hir::MutMutable, .. }) = pty.node {
-                span_lint(self.cx, MUT_MUT, ty.span, "generally you want to avoid `&mut &mut _` if possible");
+    fn visit_ty(&mut self, ty: &'tcx hir::Ty<'_>) {
+        if let hir::TyKind::Rptr(
+            _,
+            hir::MutTy {
+                ty: pty,
+                mutbl: hir::Mutability::Mut,
+            },
+        ) = ty.kind
+        {
+            if let hir::TyKind::Rptr(
+                _,
+                hir::MutTy {
+                    mutbl: hir::Mutability::Mut,
+                    ..
+                },
+            ) = pty.kind
+            {
+                span_lint(
+                    self.cx,
+                    MUT_MUT,
+                    ty.span,
+                    "generally you want to avoid `&mut &mut _` if possible",
+                );
             }
-
         }
 
         intravisit::walk_ty(self, ty);
     }
+    fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
+        intravisit::NestedVisitorMap::None
+    }
 }