1 use clippy_utils::diagnostics::span_lint_and_note;
2 use clippy_utils::source::snippet;
3 use clippy_utils::visitors::is_local_used;
4 use rustc_data_structures::fx::FxHashMap;
5 use rustc_hir::def::Res;
6 use rustc_hir::def_id::LocalDefId;
7 use rustc_hir::hir_id::ItemLocalId;
8 use rustc_hir::{Block, Body, BodyOwnerKind, Expr, ExprKind, HirId, Let, Node, Pat, PatKind, QPath, UnOp};
9 use rustc_lint::{LateContext, LateLintPass};
10 use rustc_session::{declare_tool_lint, impl_lint_pass};
11 use rustc_span::{Span, Symbol};
13 declare_clippy_lint! {
15 /// Checks for bindings that shadow other bindings already in
16 /// scope, while just changing reference level or mutability.
18 /// ### Why is this bad?
19 /// Not much, in fact it's a very common pattern in Rust
20 /// code. Still, some may opt to avoid it in their code base, they can set this
32 /// let y = &x; // use different variable name
34 #[clippy::version = "pre 1.29.0"]
37 "rebinding a name to itself, e.g., `let mut x = &mut x`"
40 declare_clippy_lint! {
42 /// Checks for bindings that shadow other bindings already in
43 /// scope, while reusing the original value.
45 /// ### Why is this bad?
46 /// Not too much, in fact it's a common pattern in Rust
47 /// code. Still, some argue that name shadowing like this hurts readability,
48 /// because a value may be bound to different things depending on position in
56 /// use different variable name:
61 #[clippy::version = "pre 1.29.0"]
64 "rebinding a name to an expression that re-uses the original value, e.g., `let x = x + 1`"
67 declare_clippy_lint! {
69 /// Checks for bindings that shadow other bindings already in
70 /// scope, either without an initialization or with one that does not even use
71 /// the original value.
73 /// ### Why is this bad?
74 /// Name shadowing can hurt readability, especially in
75 /// large code bases, because it is easy to lose track of the active binding at
76 /// any place in the code. This can be alleviated by either giving more specific
77 /// names to bindings or introducing more scopes to contain the bindings.
84 /// let x = z; // shadows the earlier binding
92 /// let w = z; // use different variable name
94 #[clippy::version = "pre 1.29.0"]
97 "rebinding a name without even using the original value"
101 pub(crate) struct Shadow {
102 bindings: Vec<(FxHashMap<Symbol, Vec<ItemLocalId>>, LocalDefId)>,
105 impl_lint_pass!(Shadow => [SHADOW_SAME, SHADOW_REUSE, SHADOW_UNRELATED]);
107 impl<'tcx> LateLintPass<'tcx> for Shadow {
108 fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) {
109 let PatKind::Binding(_, id, ident, _) = pat.kind else { return };
111 if pat.span.desugaring_kind().is_some() {
115 if ident.span.from_expansion() || ident.span.is_dummy() {
119 let HirId { owner, local_id } = id;
120 // get (or insert) the list of items for this owner and symbol
121 let (ref mut data, scope_owner) = *self.bindings.last_mut().unwrap();
122 let items_with_name = data.entry(ident.name).or_default();
124 // check other bindings with the same name, most recently seen first
125 for &prev in items_with_name.iter().rev() {
126 if prev == local_id {
127 // repeated binding in an `Or` pattern
131 if is_shadow(cx, scope_owner, prev, local_id) {
132 let prev_hir_id = HirId { owner, local_id: prev };
133 lint_shadow(cx, pat, prev_hir_id, ident.span);
134 // only lint against the "nearest" shadowed binding
139 items_with_name.push(local_id);
142 fn check_body(&mut self, cx: &LateContext<'_>, body: &Body<'_>) {
143 let hir = cx.tcx.hir();
144 let owner_id = hir.body_owner_def_id(body.id());
145 if !matches!(hir.body_owner_kind(owner_id), BodyOwnerKind::Closure) {
146 self.bindings.push((FxHashMap::default(), owner_id));
150 fn check_body_post(&mut self, cx: &LateContext<'_>, body: &Body<'_>) {
151 let hir = cx.tcx.hir();
153 hir.body_owner_kind(hir.body_owner_def_id(body.id())),
154 BodyOwnerKind::Closure
161 fn is_shadow(cx: &LateContext<'_>, owner: LocalDefId, first: ItemLocalId, second: ItemLocalId) -> bool {
162 let scope_tree = cx.tcx.region_scope_tree(owner.to_def_id());
163 if let Some(first_scope) = scope_tree.var_scope(first) {
164 if let Some(second_scope) = scope_tree.var_scope(second) {
165 return scope_tree.is_subscope_of(second_scope, first_scope);
172 fn lint_shadow(cx: &LateContext<'_>, pat: &Pat<'_>, shadowed: HirId, span: Span) {
173 let (lint, msg) = match find_init(cx, pat.hir_id) {
174 Some(expr) if is_self_shadow(cx, pat, expr, shadowed) => {
176 "`{}` is shadowed by itself in `{}`",
177 snippet(cx, pat.span, "_"),
178 snippet(cx, expr.span, "..")
182 Some(expr) if is_local_used(cx, expr, shadowed) => {
183 let msg = format!("`{}` is shadowed", snippet(cx, pat.span, "_"));
187 let msg = format!("`{}` shadows a previous, unrelated binding", snippet(cx, pat.span, "_"));
188 (SHADOW_UNRELATED, msg)
196 Some(cx.tcx.hir().span(shadowed)),
197 "previous binding is here",
201 /// Returns true if the expression is a simple transformation of a local binding such as `&x`
202 fn is_self_shadow(cx: &LateContext<'_>, pat: &Pat<'_>, mut expr: &Expr<'_>, hir_id: HirId) -> bool {
203 let hir = cx.tcx.hir();
204 let is_direct_binding = hir
205 .parent_iter(pat.hir_id)
206 .map_while(|(_id, node)| match node {
207 Node::Pat(pat) => Some(pat),
210 .all(|pat| matches!(pat.kind, PatKind::Ref(..) | PatKind::Or(_)));
211 if !is_direct_binding {
215 expr = match expr.kind {
217 | ExprKind::AddrOf(_, _, e)
226 | ExprKind::Unary(UnOp::Deref, e) => e,
227 ExprKind::Path(QPath::Resolved(None, path)) => break path.res == Res::Local(hir_id),
233 /// Finds the "init" expression for a pattern: `let <pat> = <init>;` (or `if let`) or
234 /// `match <init> { .., <pat> => .., .. }`
235 fn find_init<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Option<&'tcx Expr<'tcx>> {
236 for (_, node) in cx.tcx.hir().parent_iter(hir_id) {
237 let init = match node {
238 Node::Arm(_) | Node::Pat(_) => continue,
239 Node::Expr(expr) => match expr.kind {
240 ExprKind::Match(e, _, _) | ExprKind::Let(&Let { init: e, .. }) => Some(e),
243 Node::Local(local) => local.init,