use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};

use clippy_utils::higher;

use clippy_utils::source::snippet_with_applicability;

use clippy_utils::sugg::Sugg;

use rustc_data_structures::fx::FxHashSet;

use rustc_errors::Applicability;

use rustc_hir::{self as hir, AmbigArg, BorrowKind, Expr, ExprKind, HirId, Mutability, TyKind, intravisit};

use rustc_lint::{LateContext, LateLintPass, LintContext};

use rustc_middle::ty;

use rustc_session::impl_lint_pass;

declare_clippy_lint! {

/// ### What it does

/// Checks for instances of `mut mut` references.

///

/// ### Why is this bad?

/// This is usually just a typo or a misunderstanding of how references work.

///

/// ### Example

/// ```no_run

/// let x = &mut &mut 1;

///

/// let mut x = &mut 1;

/// let y = &mut x;

///

/// fn foo(x: &mut &mut u32) {}

/// ```

/// Use instead

/// ```no_run

/// let x = &mut 1;

///

/// let mut x = &mut 1;

/// let y = &mut *x; // reborrow

///

/// fn foo(x: &mut u32) {}

/// ```

#[clippy::version = "pre 1.29.0"]

pub MUT_MUT,

pedantic,

"usage of double mut-refs, e.g., `&mut &mut ...`"

}

impl_lint_pass!(MutMut => [MUT_MUT]);

#[derive(Default)]

pub(crate) struct MutMut {

seen_tys: FxHashSet<HirId>,

}

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<'tcx>, ty: &'tcx hir::Ty<'_, AmbigArg>) {

if let TyKind::Ref(_, mty) = ty.kind

&& mty.mutbl == Mutability::Mut

&& let TyKind::Ref(_, mty2) = mty.ty.kind

&& mty2.mutbl == Mutability::Mut

&& !ty.span.in_external_macro(cx.sess().source_map())

{

if self.seen_tys.contains(&ty.hir_id) {

// we have 2+ `&mut`s, e.g., `&mut &mut &mut x`

// and we have already flagged on the outermost `&mut &mut (&mut x)`,

// so don't flag the inner `&mut &mut (x)`

return;

}

// if there is an even longer chain, like `&mut &mut &mut x`, suggest peeling off

// all extra ones at once

let (mut t, mut t2) = (mty.ty, mty2.ty);

let mut many_muts = false;

loop {

// this should allow us to remember all the nested types, so that the `contains`

// above fails faster

self.seen_tys.insert(t.hir_id);

if let TyKind::Ref(_, next) = t2.kind

&& next.mutbl == Mutability::Mut

{

(t, t2) = (t2, next.ty);

many_muts = true;

} else {

break;

}

}

let mut applicability = Applicability::MaybeIncorrect;

let sugg = snippet_with_applicability(cx.sess(), t.span, "..", &mut applicability);

let suffix = if many_muts { "s" } else { "" };

span_lint_and_sugg(

cx,

MUT_MUT,

ty.span,

"a type of form `&mut &mut _`",

format!("remove the extra `&mut`{suffix}"),

sugg.to_string(),

applicability,

);

}

}

}

pub struct MutVisitor<'a, 'tcx> {

cx: &'a LateContext<'tcx>,

}

impl<'tcx> intravisit::Visitor<'tcx> for MutVisitor<'_, 'tcx> {

fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {

if expr.span.in_external_macro(self.cx.sess().source_map()) {

return;

}

if let Some(higher::ForLoop { arg, body, .. }) = higher::ForLoop::hir(expr) {

// A `for` loop lowers to:

// ```rust

// match ::std::iter::Iterator::next(&mut iter) {

// // ^^^^

// ```

// Let's ignore the generated code.

intravisit::walk_expr(self, arg);

intravisit::walk_expr(self, body);

} else if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, e) = expr.kind {

if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, e2) = e.kind {

if !expr.span.eq_ctxt(e.span) {

return;

}

// if there is an even longer chain, like `&mut &mut &mut x`, suggest peeling off

// all extra ones at once

let (mut e, mut e2) = (e, e2);

let mut many_muts = false;

loop {

if !e.span.eq_ctxt(e2.span) {

return;

}

if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, next) = e2.kind {

(e, e2) = (e2, next);

many_muts = true;

} else {

break;

}

}

let mut applicability = Applicability::MaybeIncorrect;

let sugg = Sugg::hir_with_applicability(self.cx, e, "..", &mut applicability);

let suffix = if many_muts { "s" } else { "" };

span_lint_hir_and_then(

self.cx,

MUT_MUT,

expr.hir_id,

expr.span,

"an expression of form `&mut &mut _`",

|diag| {

diag.span_suggestion(

expr.span,

format!("remove the extra `&mut`{suffix}"),

sugg,

applicability,

);

},

);

} else if let ty::Ref(_, ty, Mutability::Mut) = self.cx.typeck_results().expr_ty(e).kind()

&& ty.peel_refs().is_sized(self.cx.tcx, self.cx.typing_env())

{

let mut applicability = Applicability::MaybeIncorrect;

let sugg = Sugg::hir_with_applicability(self.cx, e, "..", &mut applicability).mut_addr_deref();

span_lint_hir_and_then(

self.cx,

MUT_MUT,

expr.hir_id,

expr.span,

"this expression mutably borrows a mutable reference",

|diag| {

diag.span_suggestion(expr.span, "reborrow instead", sugg, applicability);

},

);

}

}

}

}