src/tools/clippy/clippy_lints/src/mut_mut.rs

   1 use clippy_utils::diagnostics::span_lint;
   2 use clippy_utils::higher;
   3 use rustc_hir as hir;
   4 use rustc_hir::intravisit;
   5 use rustc_lint::{LateContext, LateLintPass, LintContext};
   6 use rustc_middle::lint::in_external_macro;
   7 use rustc_middle::ty;
   8 use rustc_session::{declare_lint_pass, declare_tool_lint};
   9
  10 declare_clippy_lint! {
  11     /// ### What it does
  12     /// Checks for instances of `mut mut` references.
  13     ///
  14     /// ### Why is this bad?
  15     /// Multiple `mut`s don't add anything meaningful to the
  16     /// source. This is either a copy'n'paste error, or it shows a fundamental
  17     /// misunderstanding of references.
  18     ///
  19     /// ### Example
  20     /// ```rust
  21     /// # let mut y = 1;
  22     /// let x = &mut &mut y;
  23     /// ```
  24     #[clippy::version = "pre 1.29.0"]
  25     pub MUT_MUT,
  26     pedantic,
  27     "usage of double-mut refs, e.g., `&mut &mut ...`"
  28 }
  29
  30 declare_lint_pass!(MutMut => [MUT_MUT]);
  31
  32 impl<'tcx> LateLintPass<'tcx> for MutMut {
  33     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx hir::Block<'_>) {
  34         intravisit::walk_block(&mut MutVisitor { cx }, block);
  35     }
  36
  37     fn check_ty(&mut self, cx: &LateContext<'tcx>, ty: &'tcx hir::Ty<'_>) {
  38         use rustc_hir::intravisit::Visitor;
  39
  40         MutVisitor { cx }.visit_ty(ty);
  41     }
  42 }
  43
  44 pub struct MutVisitor<'a, 'tcx> {
  45     cx: &'a LateContext<'tcx>,
  46 }
  47
  48 impl<'a, 'tcx> intravisit::Visitor<'tcx> for MutVisitor<'a, 'tcx> {
  49     fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
  50         if in_external_macro(self.cx.sess(), expr.span) {
  51             return;
  52         }
  53
  54         if let Some(higher::ForLoop { arg, body, .. }) = higher::ForLoop::hir(expr) {
  55             // A `for` loop lowers to:
  56             // ```rust
  57             // match ::std::iter::Iterator::next(&mut iter) {
  58             // //                                ^^^^
  59             // ```
  60             // Let's ignore the generated code.
  61             intravisit::walk_expr(self, arg);
  62             intravisit::walk_expr(self, body);
  63         } else if let hir::ExprKind::AddrOf(hir::BorrowKind::Ref, hir::Mutability::Mut, e) = expr.kind {
  64             if let hir::ExprKind::AddrOf(hir::BorrowKind::Ref, hir::Mutability::Mut, _) = e.kind {
  65                 span_lint(
  66                     self.cx,
  67                     MUT_MUT,
  68                     expr.span,
  69                     "generally you want to avoid `&mut &mut _` if possible",
  70                 );
  71             } else if let ty::Ref(_, ty, hir::Mutability::Mut) = self.cx.typeck_results().expr_ty(e).kind() {
  72                 if ty.peel_refs().is_sized(self.cx.tcx, self.cx.param_env) {
  73                     span_lint(
  74                         self.cx,
  75                         MUT_MUT,
  76                         expr.span,
  77                         "this expression mutably borrows a mutable reference. Consider reborrowing",
  78                     );
  79                 }
  80             }
  81         }
  82     }
  83
  84     fn visit_ty(&mut self, ty: &'tcx hir::Ty<'_>) {
  85         if in_external_macro(self.cx.sess(), ty.span) {
  86             return;
  87         }
  88
  89         if let hir::TyKind::Rptr(
  90             _,
  91             hir::MutTy {
  92                 ty: pty,
  93                 mutbl: hir::Mutability::Mut,
  94             },
  95         ) = ty.kind
  96         {
  97             if let hir::TyKind::Rptr(
  98                 _,
  99                 hir::MutTy {
 100                     mutbl: hir::Mutability::Mut,
 101                     ..
 102                 },
 103             ) = pty.kind
 104             {
 105                 span_lint(
 106                     self.cx,
 107                     MUT_MUT,
 108                     ty.span,
 109                     "generally you want to avoid `&mut &mut _` if possible",
 110                 );
 111             }
 112         }
 113
 114         intravisit::walk_ty(self, ty);
 115     }
 116 }