#[subdiagnostic]

pub(crate) wanted_constant: Option<WantedConstant>,

#[note(mir_build_unreachable_pattern_const_reexport_accessible)]

pub(crate) accessible_constant: Option<Span>,

#[note(mir_build_unreachable_pattern_const_inaccessible)]

pub(crate) inaccessible_constant: Option<Span>,

#[note(mir_build_unreachable_pattern_let_binding)]

pub(crate) pattern_let_binding: Option<Span>,

pub(crate) struct WantedConstant {

#[primary_span]

pub(crate) span: Span,

pub(crate) is_typo: bool,

pub(crate) const_name: String,

pub(crate) const_path: String,

use rustc_infer::infer::TyCtxtInferExt;

use rustc_lint::Level;

use rustc_span::edit_distance::find_best_match_for_name;

use rustc_trait_selection::infer::InferCtxtExt;

wanted_constant: None,

accessible_constant: None,

inaccessible_constant: None,

pattern_let_binding: None,

// A binding pattern that matches all, a single binding name.

let pat = covering_pat.data();

lint.covered_by_catchall = Some(pat.span);

find_fallback_pattern_typo(cx, hir_id, pat, &mut lint);

fn find_fallback_pattern_typo<'tcx>(

cx: &PatCtxt<'_, 'tcx>,

hir_id: HirId,

pat: &Pat<'tcx>,

lint: &mut UnreachablePattern<'_>,

) {

if let (Level::Allow, _) = cx.tcx.lint_level_at_node(UNREACHABLE_PATTERNS, hir_id) {

// This is because we use `with_no_trimmed_paths` later, so if we never emit the lint we'd

// ICE. At the same time, we don't really need to do all of this if we won't emit anything.

return;

}

if let PatKind::Binding { name, subpattern: None, ty, .. } = pat.kind {

// See if the binding might have been a `const` that was mistyped or out of scope.

let mut accessible = vec![];

let mut accessible_path = vec![];

let mut inaccessible = vec![];

let mut imported = vec![];

let mut imported_spans = vec![];

let infcx = cx.tcx.infer_ctxt().build(ty::TypingMode::non_body_analysis());

let parent = cx.tcx.hir().get_parent_item(hir_id);

for item in cx.tcx.hir_crate_items(()).free_items() {

if let DefKind::Use = cx.tcx.def_kind(item.owner_id) {

// Look for consts being re-exported.

let item = cx.tcx.hir().expect_item(item.owner_id.def_id);

let use_name = item.ident.name;

let hir::ItemKind::Use(path, _) = item.kind else {

continue;

};

for res in &path.res {

if let Res::Def(DefKind::Const, id) = res

&& infcx.can_eq(cx.param_env, ty, cx.tcx.type_of(id).instantiate_identity())

{

if cx.tcx.visibility(id).is_accessible_from(parent, cx.tcx) {

// The original const is accessible, suggest using it directly.

let item_name = cx.tcx.item_name(*id);

accessible.push(item_name);

accessible_path.push(with_no_trimmed_paths!(cx.tcx.def_path_str(id)));

} else if cx

.tcx

.visibility(item.owner_id)

.is_accessible_from(parent, cx.tcx)

{

// The const is accessible only through the re-export, point at

// the `use`.

imported.push(use_name);

imported_spans.push(item.ident.span);

}

}

}

}

if let DefKind::Const = cx.tcx.def_kind(item.owner_id)

&& infcx.can_eq(

cx.param_env,

ty,

cx.tcx.type_of(item.owner_id).instantiate_identity(),

)

{

// Look for local consts.

let item_name = cx.tcx.item_name(item.owner_id.into());

let vis = cx.tcx.visibility(item.owner_id);

if vis.is_accessible_from(parent, cx.tcx) {

accessible.push(item_name);

let path = if item_name == name {

// We know that the const wasn't in scope because it has the exact

// same name, so we suggest the full path.

with_no_trimmed_paths!(cx.tcx.def_path_str(item.owner_id))

} else {

// The const is likely just typoed, and nothing else.

cx.tcx.def_path_str(item.owner_id)

};

accessible_path.push(path);

} else if name == item_name {

// The const exists somewhere in this crate, but it can't be imported

// from this pattern's scope. We'll just point at its definition.

inaccessible.push(cx.tcx.def_span(item.owner_id));

}

}

}

if let Some((i, &const_name)) =

accessible.iter().enumerate().find(|(_, &const_name)| const_name == name)

{

// The pattern name is an exact match, so the pattern needed to be imported.

lint.wanted_constant = Some(WantedConstant {

span: pat.span,

is_typo: false,

const_name: const_name.to_string(),

const_path: accessible_path[i].clone(),

});

} else if let Some(name) = find_best_match_for_name(&accessible, name, None) {

// The pattern name is likely a typo.

lint.wanted_constant = Some(WantedConstant {

span: pat.span,

is_typo: true,

const_name: name.to_string(),

const_path: name.to_string(),

});

} else if let Some(i) =

imported.iter().enumerate().find(|(_, &const_name)| const_name == name).map(|(i, _)| i)

{

// The const with the exact name wasn't re-exported from an import in this

// crate, we point at the import.

lint.accessible_constant = Some(imported_spans[i]);

} else if let Some(name) = find_best_match_for_name(&imported, name, None) {

// The typoed const wasn't re-exported by an import in this crate, we suggest

// the right name (which will likely require another follow up suggestion).

lint.wanted_constant = Some(WantedConstant {

span: pat.span,

is_typo: true,

const_path: name.to_string(),

const_name: name.to_string(),

});

} else if !inaccessible.is_empty() {

for span in inaccessible {

// The const with the exact name match isn't accessible, we just point at it.

lint.inaccessible_constant = Some(span);

}

} else {

// Look for local bindings for people that might have gotten confused with how

// `let` and `const` works.

for (_, node) in cx.tcx.hir().parent_iter(hir_id) {

match node {

hir::Node::Stmt(hir::Stmt { kind: hir::StmtKind::Let(let_stmt), .. }) => {

if let hir::PatKind::Binding(_, _, binding_name, _) = let_stmt.pat.kind {

if name == binding_name.name {

lint.pattern_let_binding = Some(binding_name.span);

}

}

}

hir::Node::Block(hir::Block { stmts, .. }) => {

for stmt in *stmts {

if let hir::StmtKind::Let(let_stmt) = stmt.kind {

if let hir::PatKind::Binding(_, _, binding_name, _) =

let_stmt.pat.kind

{

if name == binding_name.name {

lint.pattern_let_binding = Some(binding_name.span);

}

}

}

}

}

hir::Node::Item(_) => break,

_ => {}

}

}

}

}

#![deny(unreachable_patterns)] //~ NOTE the lint level is defined here

mod x {

pub use std::env::consts::ARCH;

const X: i32 = 0; //~ NOTE there is a constant of the same name

fn main() {

let input: i32 = 42;

const god: i32 = 1;

const GOOD: i32 = 1;

const BAD: i32 = 2;

let name: i32 = 42; //~ NOTE there is a binding of the same name

match input {

X => {} //~ NOTE matches any value

_ => {} //~ ERROR unreachable pattern

//~^ NOTE no value can reach this

}

match input {

GOD => {} //~ HELP you might have meant to pattern match against the value of similarly named constant `god`

//~^ NOTE matches any value

_ => {} //~ ERROR unreachable pattern

//~^ NOTE no value can reach this

}

match input {

GOOOD => {} //~ HELP you might have meant to pattern match against the value of similarly named constant `GOOD`

//~^ NOTE matches any value

_ => {} //~ ERROR unreachable pattern

//~^ NOTE no value can reach this

}

match input {

name => {}

//~^ NOTE matches any value

_ => {} //~ ERROR unreachable pattern

//~^ NOTE no value can reach this

}

match "" {

ARCH => {} //~ HELP you might have meant to pattern match against the value of constant `ARCH`

//~^ NOTE matches any value

_ => {} //~ ERROR unreachable pattern

//~^ NOTE no value can reach this

}

error: unreachable pattern

--> $DIR/const-with-typo-in-pattern-binding.rs:18:9

|

LL | X => {}

| - matches any value

LL | _ => {}

| ^ no value can reach this

|

note: there is a constant of the same name, which could have been used to pattern match against its value instead of introducing a new catch-all binding, but it is not accessible from this scope

--> $DIR/const-with-typo-in-pattern-binding.rs:5:5

|

LL | const X: i32 = 0;

| ^^^^^^^^^^^^

note: the lint level is defined here

--> $DIR/const-with-typo-in-pattern-binding.rs:1:9

|

LL | #![deny(unreachable_patterns)]

| ^^^^^^^^^^^^^^^^^^^^

error: unreachable pattern

--> $DIR/const-with-typo-in-pattern-binding.rs:24:9

|

LL | GOD => {}

| --- matches any value

LL |

LL | _ => {}

| ^ no value can reach this

|

help: you might have meant to pattern match against the value of similarly named constant `god` instead of introducing a new catch-all binding

|

LL | god => {}

| ~~~

error: unreachable pattern

--> $DIR/const-with-typo-in-pattern-binding.rs:30:9

|

LL | GOOOD => {}

| ----- matches any value

LL |

LL | _ => {}

| ^ no value can reach this

|

help: you might have meant to pattern match against the value of similarly named constant `GOOD` instead of introducing a new catch-all binding

|

LL | GOOD => {}

| ~~~~

error: unreachable pattern

--> $DIR/const-with-typo-in-pattern-binding.rs:36:9

|

LL | name => {}

| ---- matches any value

LL |

LL | _ => {}

| ^ no value can reach this

|

note: there is a binding of the same name; if you meant to pattern match against the value of that binding, that is a feature of constants that is not available for `let` bindings

--> $DIR/const-with-typo-in-pattern-binding.rs:14:9

|

LL | let name: i32 = 42;

| ^^^^

error: unreachable pattern

--> $DIR/const-with-typo-in-pattern-binding.rs:42:9

|

LL | ARCH => {}

| ---- matches any value

LL |

LL | _ => {}

| ^ no value can reach this

|

help: you might have meant to pattern match against the value of constant `ARCH` instead of introducing a new catch-all binding

|

LL | std::env::consts::ARCH => {}

| ~~~~~~~~~~~~~~~~~~~~~~

error: aborting due to 5 previous errors