rust/clippy_lints/src/redundant_locals.rs

use clippy_utils::diagnostics::span_lint_and_help;
use clippy_utils::is_from_proc_macro;
use clippy_utils::ty::needs_ordered_drop;
use rustc_ast::Mutability;
use rustc_hir::def::Res;
use rustc_hir::{
    BindingAnnotation, ByRef, Expr, ExprKind, HirId, Local, Node, Pat, PatKind, QPath,
};
use rustc_lint::{LateContext, LateLintPass, LintContext};
use rustc_middle::lint::{in_external_macro, is_from_async_await};
use rustc_session::{declare_lint_pass, declare_tool_lint};
use rustc_span::symbol::Ident;
use rustc_span::DesugaringKind;

declare_clippy_lint! {
    /// ### What it does
    /// Checks for redundant redefinitions of local bindings.
    ///
    /// ### Why is this bad?
    /// Redundant redefinitions of local bindings do not change behavior and are likely to be unintended.
    ///
    /// Note that although these bindings do not affect your code's meaning, they _may_ affect `rustc`'s stack allocation.
    ///
    /// ### Example
    /// ```rust
    /// let a = 0;
    /// let a = a;
    ///
    /// fn foo(b: i32) {
    ///    let b = b;
    /// }
    /// ```
    /// Use instead:
    /// ```rust
    /// let a = 0;
    /// // no redefinition with the same name
    ///
    /// fn foo(b: i32) {
    ///   // no redefinition with the same name
    /// }
    /// ```
    #[clippy::version = "1.72.0"]
    pub REDUNDANT_LOCALS,
    correctness,
    "redundant redefinition of a local binding"
}
declare_lint_pass!(RedundantLocals => [REDUNDANT_LOCALS]);

impl<'tcx> LateLintPass<'tcx> for RedundantLocals {
    fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'tcx>) {
        if_chain! {
            if !local.span.is_desugaring(DesugaringKind::Async);
            // the pattern is a single by-value binding
            if let PatKind::Binding(BindingAnnotation(ByRef::No, mutability), _, ident, None) = local.pat.kind;
            // the binding is not type-ascribed
            if local.ty.is_none();
            // the expression is a resolved path
            if let Some(expr) = local.init;
            if let ExprKind::Path(qpath @ QPath::Resolved(None, path)) = expr.kind;
            // the path is a single segment equal to the local's name
            if let [last_segment] = path.segments;
            if last_segment.ident == ident;
            // resolve the path to its defining binding pattern
            if let Res::Local(binding_id) = cx.qpath_res(&qpath, expr.hir_id);
            if let Node::Pat(binding_pat) = cx.tcx.hir().get(binding_id);
            // the previous binding has the same mutability
            if find_binding(binding_pat, ident).unwrap().1 == mutability;
            // the local does not change the effect of assignments to the binding. see #11290
            if !affects_assignments(cx, mutability, binding_id, local.hir_id);
            // the local does not affect the code's drop behavior
            if !affects_drop_behavior(cx, binding_id, local.hir_id, expr);
            // the local is user-controlled
            if !in_external_macro(cx.sess(), local.span);
            if !is_from_proc_macro(cx, expr);
            // Async function parameters are lowered into the closure body, so we can't lint them.
            // see `lower_maybe_async_body` in `rust_ast_lowering`
            if !is_from_async_await(local.span);
            then {
                span_lint_and_help(
                    cx,
                    REDUNDANT_LOCALS,
                    vec![binding_pat.span, local.span],
                    "redundant redefinition of a binding",
                    None,
                    &format!("remove the redefinition of `{ident}`"),
                );
            }
        }
    }
}

/// Find the annotation of a binding introduced by a pattern, or `None` if it's not introduced.
fn find_binding(pat: &Pat<'_>, name: Ident) -> Option<BindingAnnotation> {
    let mut ret = None;

    pat.each_binding_or_first(&mut |annotation, _, _, ident| {
        if ident == name {
            ret = Some(annotation);
        }
    });

    ret
}

/// Check if a rebinding of a local changes the effect of assignments to the binding.
fn affects_assignments(cx: &LateContext<'_>, mutability: Mutability, bind: HirId, rebind: HirId) -> bool {
    let hir = cx.tcx.hir();

    // the binding is mutable and the rebinding is in a different scope than the original binding
    mutability == Mutability::Mut && hir.get_enclosing_scope(bind) != hir.get_enclosing_scope(rebind)
}

/// Check if a rebinding of a local affects the code's drop behavior.
fn affects_drop_behavior<'tcx>(
    cx: &LateContext<'tcx>,
    bind: HirId,
    rebind: HirId,
    rebind_expr: &Expr<'tcx>,
) -> bool {
    let hir = cx.tcx.hir();

    // the rebinding is in a different scope than the original binding
    // and the type of the binding cares about drop order
    hir.get_enclosing_scope(bind) != hir.get_enclosing_scope(rebind)
        && needs_ordered_drop(cx, cx.typeck_results().expr_ty(rebind_expr))
}