Fix unused_variables typo suggestions for const patterns

onehr · onehr · commit b6a1b9ea1624 · 2026-05-25T16:16:46.000+08:00
diff --git a/compiler/rustc_mir_transform/src/liveness.rs b/compiler/rustc_mir_transform/src/liveness.rs
@@ -168,13 +168,15 @@ fn is_capture(place: PlaceRef<'_>) -> bool {
     }
 }
 
-/// Give a diagnostic when an unused variable may be a typo of a unit variant or a struct.
+/// Give a diagnostic when an unused variable may be a typo of a unit variant,
+/// unit struct, or const.
 fn maybe_suggest_unit_pattern_typo<'tcx>(
     tcx: TyCtxt<'tcx>,
     body_def_id: DefId,
     name: Symbol,
     span: Span,
     ty: Ty<'tcx>,
+    allow_consts: bool,
 ) -> Option<errors::PatternTypo> {
     if let ty::Adt(adt_def, _) = ty.peel_refs().kind() {
         let variant_names: Vec<_> = adt_def
@@ -191,13 +193,17 @@ fn maybe_suggest_unit_pattern_typo<'tcx>(
         {
             return Some(errors::PatternTypo {
                 span,
-                code: with_no_trimmed_paths!(tcx.def_path_str(variant.def_id)),
+                code: pattern_item_path(tcx, body_def_id, variant.def_id),
                 kind: tcx.def_descr(variant.def_id),
                 item_name: variant.name,
             });
         }
     }
 
+    if !allow_consts {
+        return None;
+    }
+
     // Look for consts of the same type with similar names as well,
     // not just unit structs and variants.
     let constants = tcx
@@ -215,7 +221,7 @@ fn maybe_suggest_unit_pattern_typo<'tcx>(
     {
         return Some(errors::PatternTypo {
             span,
-            code: with_no_trimmed_paths!(tcx.def_path_str(def_id)),
+            code: pattern_item_path(tcx, body_def_id, def_id.to_def_id()),
             kind: "constant",
             item_name,
         });
@@ -224,6 +230,64 @@ fn maybe_suggest_unit_pattern_typo<'tcx>(
     None
 }
 
+fn pattern_item_path(tcx: TyCtxt<'_>, body_def_id: DefId, item_def_id: DefId) -> String {
+    if is_nested_in(tcx, item_def_id, body_def_id) {
+        return relative_item_path(tcx, body_def_id, item_def_id);
+    }
+
+    let body_mod = nearest_parent_module(tcx, body_def_id);
+    if body_mod == nearest_parent_module(tcx, item_def_id) {
+        relative_item_path(tcx, body_mod, item_def_id)
+    } else if item_def_id.is_local() && !body_mod.is_top_level_module() {
+        format!("{}::{}", kw::Crate, with_no_trimmed_paths!(tcx.def_path_str(item_def_id)))
+    } else {
+        with_no_trimmed_paths!(tcx.def_path_str(item_def_id))
+    }
+}
+
+fn is_nested_in(tcx: TyCtxt<'_>, mut def_id: DefId, parent_def_id: DefId) -> bool {
+    while let Some(parent) = tcx.opt_parent(def_id) {
+        if parent == parent_def_id {
+            return true;
+        }
+        def_id = parent;
+    }
+
+    false
+}
+
+fn relative_item_path(tcx: TyCtxt<'_>, parent_def_id: DefId, item_def_id: DefId) -> String {
+    let mut def_id = item_def_id;
+    let mut path = Vec::new();
+
+    loop {
+        if def_id == parent_def_id {
+            break;
+        }
+        if let Some(name) = tcx.opt_item_name(def_id) {
+            path.push(name.to_string());
+        }
+        let Some(parent) = tcx.opt_parent(def_id) else {
+            return with_no_trimmed_paths!(tcx.def_path_str(item_def_id));
+        };
+        def_id = parent;
+    }
+
+    path.reverse();
+    path.join("::")
+}
+
+fn nearest_parent_module(tcx: TyCtxt<'_>, mut def_id: DefId) -> DefId {
+    while let Some(parent) = tcx.opt_parent(def_id) {
+        def_id = parent;
+        if matches!(tcx.def_kind(def_id), DefKind::Mod) {
+            return def_id;
+        }
+    }
+
+    def_id
+}
+
 /// Return whether we should consider the current place as a drop guard and skip reporting.
 fn maybe_drop_guard<'tcx>(
     tcx: TyCtxt<'tcx>,
@@ -977,15 +1041,19 @@ impl<'a, 'tcx> AssignmentResult<'a, 'tcx> {
                 && introductions.iter().any(|intro| intro.span.eq_ctxt(def_span));
 
             let maybe_suggest_typo = || {
-                if let LocalKind::Arg = self.body.local_kind(local) {
+                if matches!(self.body.local_kind(local), LocalKind::Arg) {
                     None
                 } else {
+                    // In a bare `let x = ...`, replacing `x` with a const path would make the
+                    // pattern refutable. Keep the existing unit ADT typo behavior unchanged.
+                    let allow_consts = !matches!(binding.opt_match_place, Some((None, _)));
                     maybe_suggest_unit_pattern_typo(
                         tcx,
                         self.body.source.def_id(),
                         name,
                         def_span,
                         decl.ty,
+                        allow_consts,
                     )
                 }
             };
diff --git a/tests/ui/lint/unused/unused-variables-const-pattern-typo.e2015.stderr b/tests/ui/lint/unused/unused-variables-const-pattern-typo.e2015.stderr
@@ -0,0 +1,77 @@
+error: unused variable: `x`
+  --> $DIR/unused-variables-const-pattern-typo.rs:17:18
+   |
+LL |         let Some(x) = x else { return };
+   |                  ^
+   |
+note: the lint level is defined here
+  --> $DIR/unused-variables-const-pattern-typo.rs:9:9
+   |
+LL | #![deny(unused_variables)]
+   |         ^^^^^^^^^^^^^^^^
+help: you might have meant to pattern match on the similarly named constant `X`
+   |
+LL -         let Some(x) = x else { return };
+LL +         let Some(crate::enclosed::X) = x else { return };
+   |
+help: if this is intentional, prefix it with an underscore
+   |
+LL |         let Some(_x) = x else { return };
+   |                  +
+
+error: unused variable: `x`
+  --> $DIR/unused-variables-const-pattern-typo.rs:25:13
+   |
+LL |         let x = system::Y;
+   |             ^ help: if this is intentional, prefix it with an underscore: `_x`
+
+error: unused variable: `good`
+  --> $DIR/unused-variables-const-pattern-typo.rs:34:18
+   |
+LL |         let Some(good) = x else { return };
+   |                  ^^^^
+   |
+help: you might have meant to pattern match on the similarly named constant `GOOD`
+   |
+LL -         let Some(good) = x else { return };
+LL +         let Some(GOOD) = x else { return };
+   |
+help: if this is intentional, prefix it with an underscore
+   |
+LL |         let Some(_good) = x else { return };
+   |                  +
+
+error: unused variable: `local`
+  --> $DIR/unused-variables-const-pattern-typo.rs:41:14
+   |
+LL |     let Some(local) = x else { return };
+   |              ^^^^^
+   |
+help: you might have meant to pattern match on the similarly named constant `LOCAL`
+   |
+LL -     let Some(local) = x else { return };
+LL +     let Some(LOCAL) = x else { return };
+   |
+help: if this is intentional, prefix it with an underscore
+   |
+LL |     let Some(_local) = x else { return };
+   |              +
+
+error: unused variable: `ready`
+  --> $DIR/unused-variables-const-pattern-typo.rs:53:18
+   |
+LL |         let Some(ready) = x else { return };
+   |                  ^^^^^
+   |
+help: you might have meant to pattern match on the similarly named variant `Ready`
+   |
+LL -         let Some(ready) = x else { return };
+LL +         let Some(crate::variants::State::Ready) = x else { return };
+   |
+help: if this is intentional, prefix it with an underscore
+   |
+LL |         let Some(_ready) = x else { return };
+   |                  +
+
+error: aborting due to 5 previous errors
+
diff --git a/tests/ui/lint/unused/unused-variables-const-pattern-typo.e2021.stderr b/tests/ui/lint/unused/unused-variables-const-pattern-typo.e2021.stderr
@@ -0,0 +1,77 @@
+error: unused variable: `x`
+  --> $DIR/unused-variables-const-pattern-typo.rs:17:18
+   |
+LL |         let Some(x) = x else { return };
+   |                  ^
+   |
+note: the lint level is defined here
+  --> $DIR/unused-variables-const-pattern-typo.rs:9:9
+   |
+LL | #![deny(unused_variables)]
+   |         ^^^^^^^^^^^^^^^^
+help: you might have meant to pattern match on the similarly named constant `X`
+   |
+LL -         let Some(x) = x else { return };
+LL +         let Some(crate::enclosed::X) = x else { return };
+   |
+help: if this is intentional, prefix it with an underscore
+   |
+LL |         let Some(_x) = x else { return };
+   |                  +
+
+error: unused variable: `x`
+  --> $DIR/unused-variables-const-pattern-typo.rs:25:13
+   |
+LL |         let x = system::Y;
+   |             ^ help: if this is intentional, prefix it with an underscore: `_x`
+
+error: unused variable: `good`
+  --> $DIR/unused-variables-const-pattern-typo.rs:34:18
+   |
+LL |         let Some(good) = x else { return };
+   |                  ^^^^
+   |
+help: you might have meant to pattern match on the similarly named constant `GOOD`
+   |
+LL -         let Some(good) = x else { return };
+LL +         let Some(GOOD) = x else { return };
+   |
+help: if this is intentional, prefix it with an underscore
+   |
+LL |         let Some(_good) = x else { return };
+   |                  +
+
+error: unused variable: `local`
+  --> $DIR/unused-variables-const-pattern-typo.rs:41:14
+   |
+LL |     let Some(local) = x else { return };
+   |              ^^^^^
+   |
+help: you might have meant to pattern match on the similarly named constant `LOCAL`
+   |
+LL -     let Some(local) = x else { return };
+LL +     let Some(LOCAL) = x else { return };
+   |
+help: if this is intentional, prefix it with an underscore
+   |
+LL |     let Some(_local) = x else { return };
+   |              +
+
+error: unused variable: `ready`
+  --> $DIR/unused-variables-const-pattern-typo.rs:53:18
+   |
+LL |         let Some(ready) = x else { return };
+   |                  ^^^^^
+   |
+help: you might have meant to pattern match on the similarly named variant `Ready`
+   |
+LL -         let Some(ready) = x else { return };
+LL +         let Some(crate::variants::State::Ready) = x else { return };
+   |
+help: if this is intentional, prefix it with an underscore
+   |
+LL |         let Some(_ready) = x else { return };
+   |                  +
+
+error: aborting due to 5 previous errors
+
diff --git a/tests/ui/lint/unused/unused-variables-const-pattern-typo.rs b/tests/ui/lint/unused/unused-variables-const-pattern-typo.rs
@@ -0,0 +1,62 @@
+//@ revisions: e2015 e2021
+//@[e2015] edition:2015
+//@[e2021] edition:2021
+
+// Regression test for https://github.com/rust-lang/rust/issues/147595.
+// The `unused_variables` typo suggestion must not print a pattern path that
+// cannot be resolved from the binding site.
+
+#![deny(unused_variables)]
+
+mod enclosed {
+    pub const X: i32 = 1;
+}
+
+mod separated {
+    pub fn let_else_path_qualification(x: Option<i32>) {
+        let Some(x) = x else { return };
+        //~^ ERROR unused variable: `x`
+    }
+}
+
+mod utils {
+    pub fn simple_binding_with_imported_const() {
+        use crate::system;
+        let x = system::Y;
+        //~^ ERROR unused variable: `x`
+    }
+}
+
+mod same_module {
+    const GOOD: i32 = 0;
+
+    pub fn same_module_const_suggestion(x: Option<i32>) {
+        let Some(good) = x else { return };
+        //~^ ERROR unused variable: `good`
+    }
+}
+
+fn function_local_const_suggestion(x: Option<i32>) {
+    const LOCAL: i32 = 0;
+    let Some(local) = x else { return };
+    //~^ ERROR unused variable: `local`
+}
+
+mod variants {
+    pub enum State {
+        Ready,
+    }
+}
+
+mod separated_variant {
+    pub fn cross_module_variant_path(x: Option<crate::variants::State>) {
+        let Some(ready) = x else { return };
+        //~^ ERROR unused variable: `ready`
+    }
+}
+
+mod system {
+    pub const Y: u32 = 0;
+}
+
+fn main() {}
