1use rustc_arena::{DroplessArena, TypedArena};
2use rustc_ast::Mutability;
3use rustc_data_structures::fx::FxIndexSet;
4use rustc_data_structures::stack::ensure_sufficient_stack;
5use rustc_errors::codes::*;
6use rustc_errors::{Applicability, ErrorGuaranteed, MultiSpan, struct_span_code_err};
7use rustc_hir::def::*;
8use rustc_hir::def_id::LocalDefId;
9use rustc_hir::{self as hir, BindingMode, ByRef, HirId, MatchSource};
10use rustc_infer::infer::TyCtxtInferExt;
11use rustc_lint::Level;
12use rustc_middle::bug;
13use rustc_middle::thir::visit::Visitor;
14use rustc_middle::thir::*;
15use rustc_middle::ty::print::with_no_trimmed_paths;
16use rustc_middle::ty::{self, AdtDef, Ty, TyCtxt};
17use rustc_pattern_analysis::errors::Uncovered;
18use rustc_pattern_analysis::rustc::{
19 Constructor, DeconstructedPat, MatchArm, RedundancyExplanation, RevealedTy,
20 RustcPatCtxt as PatCtxt, Usefulness, UsefulnessReport, WitnessPat,
21};
22use rustc_session::lint::builtin::{
23 BINDINGS_WITH_VARIANT_NAME, IRREFUTABLE_LET_PATTERNS, UNREACHABLE_PATTERNS,
24};
25use rustc_span::edit_distance::find_best_match_for_name;
26use rustc_span::hygiene::DesugaringKind;
27use rustc_span::{Ident, Span};
28use rustc_trait_selection::infer::InferCtxtExt;
29use tracing::instrument;
30
31use crate::errors::*;
32use crate::fluent_generated as fluent;
33
34pub(crate) fn check_match(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Result<(), ErrorGuaranteed> {
35 let typeck_results = tcx.typeck(def_id);
36 let (thir, expr) = tcx.thir_body(def_id)?;
37 let thir = thir.borrow();
38 let pattern_arena = TypedArena::default();
39 let dropless_arena = DroplessArena::default();
40 let mut visitor = MatchVisitor {
41 tcx,
42 thir: &*thir,
43 typeck_results,
44 typing_env: ty::TypingEnv::non_body_analysis(tcx, def_id),
46 lint_level: tcx.local_def_id_to_hir_id(def_id),
47 let_source: LetSource::None,
48 pattern_arena: &pattern_arena,
49 dropless_arena: &dropless_arena,
50 error: Ok(()),
51 };
52 visitor.visit_expr(&thir[expr]);
53
54 let origin = match tcx.def_kind(def_id) {
55 DefKind::AssocFn | DefKind::Fn => "function argument",
56 DefKind::Closure => "closure argument",
57 _ if thir.params.is_empty() => "",
60 kind => bug!("unexpected function parameters in THIR: {kind:?} {def_id:?}"),
61 };
62
63 for param in thir.params.iter() {
64 if let Some(box ref pattern) = param.pat {
65 visitor.check_binding_is_irrefutable(pattern, origin, None, None);
66 }
67 }
68 visitor.error
69}
70
71#[derive(Debug, Copy, Clone, PartialEq)]
72enum RefutableFlag {
73 Irrefutable,
74 Refutable,
75}
76use RefutableFlag::*;
77
78#[derive(Clone, Copy, Debug, PartialEq, Eq)]
79enum LetSource {
80 None,
81 PlainLet,
82 IfLet,
83 IfLetGuard,
84 LetElse,
85 WhileLet,
86 Else,
87 ElseIfLet,
88}
89
90struct MatchVisitor<'p, 'tcx> {
91 tcx: TyCtxt<'tcx>,
92 typing_env: ty::TypingEnv<'tcx>,
93 typeck_results: &'tcx ty::TypeckResults<'tcx>,
94 thir: &'p Thir<'tcx>,
95 lint_level: HirId,
96 let_source: LetSource,
97 pattern_arena: &'p TypedArena<DeconstructedPat<'p, 'tcx>>,
98 dropless_arena: &'p DroplessArena,
99 error: Result<(), ErrorGuaranteed>,
103}
104
105impl<'p, 'tcx> Visitor<'p, 'tcx> for MatchVisitor<'p, 'tcx> {
108 fn thir(&self) -> &'p Thir<'tcx> {
109 self.thir
110 }
111
112 #[instrument(level = "trace", skip(self))]
113 fn visit_arm(&mut self, arm: &'p Arm<'tcx>) {
114 self.with_lint_level(arm.lint_level, |this| {
115 if let Some(expr) = arm.guard {
116 this.with_let_source(LetSource::IfLetGuard, |this| {
117 this.visit_expr(&this.thir[expr])
118 });
119 }
120 this.visit_pat(&arm.pattern);
121 this.visit_expr(&self.thir[arm.body]);
122 });
123 }
124
125 #[instrument(level = "trace", skip(self))]
126 fn visit_expr(&mut self, ex: &'p Expr<'tcx>) {
127 match ex.kind {
128 ExprKind::Scope { value, lint_level, .. } => {
129 self.with_lint_level(lint_level, |this| {
130 this.visit_expr(&this.thir[value]);
131 });
132 return;
133 }
134 ExprKind::If { cond, then, else_opt, if_then_scope: _ } => {
135 let let_source = match ex.span.desugaring_kind() {
137 Some(DesugaringKind::WhileLoop) => LetSource::WhileLet,
138 _ => match self.let_source {
139 LetSource::Else => LetSource::ElseIfLet,
140 _ => LetSource::IfLet,
141 },
142 };
143 self.with_let_source(let_source, |this| this.visit_expr(&self.thir[cond]));
144 self.with_let_source(LetSource::None, |this| {
145 this.visit_expr(&this.thir[then]);
146 });
147 if let Some(else_) = else_opt {
148 self.with_let_source(LetSource::Else, |this| {
149 this.visit_expr(&this.thir[else_])
150 });
151 }
152 return;
153 }
154 ExprKind::Match { scrutinee, box ref arms, match_source } => {
155 self.check_match(scrutinee, arms, match_source, ex.span);
156 }
157 ExprKind::LoopMatch {
158 match_data: box LoopMatchMatchData { scrutinee, box ref arms, span },
159 ..
160 } => {
161 self.check_match(scrutinee, arms, MatchSource::Normal, span);
162 }
163 ExprKind::Let { box ref pat, expr } => {
164 self.check_let(pat, Some(expr), ex.span);
165 }
166 ExprKind::LogicalOp { op: LogicalOp::And, .. }
167 if !matches!(self.let_source, LetSource::None) =>
168 {
169 let mut chain_refutabilities = Vec::new();
170 let Ok(()) = self.visit_land(ex, &mut chain_refutabilities) else { return };
171 if chain_refutabilities.iter().any(|x| x.is_some()) {
173 self.check_let_chain(chain_refutabilities, ex.span);
174 }
175 return;
176 }
177 _ => {}
178 };
179 self.with_let_source(LetSource::None, |this| visit::walk_expr(this, ex));
180 }
181
182 fn visit_stmt(&mut self, stmt: &'p Stmt<'tcx>) {
183 match stmt.kind {
184 StmtKind::Let {
185 box ref pattern, initializer, else_block, lint_level, span, ..
186 } => {
187 self.with_lint_level(lint_level, |this| {
188 let let_source =
189 if else_block.is_some() { LetSource::LetElse } else { LetSource::PlainLet };
190 this.with_let_source(let_source, |this| {
191 this.check_let(pattern, initializer, span)
192 });
193 visit::walk_stmt(this, stmt);
194 });
195 }
196 StmtKind::Expr { .. } => {
197 visit::walk_stmt(self, stmt);
198 }
199 }
200 }
201}
202
203impl<'p, 'tcx> MatchVisitor<'p, 'tcx> {
204 #[instrument(level = "trace", skip(self, f))]
205 fn with_let_source(&mut self, let_source: LetSource, f: impl FnOnce(&mut Self)) {
206 let old_let_source = self.let_source;
207 self.let_source = let_source;
208 ensure_sufficient_stack(|| f(self));
209 self.let_source = old_let_source;
210 }
211
212 fn with_lint_level<T>(
213 &mut self,
214 new_lint_level: LintLevel,
215 f: impl FnOnce(&mut Self) -> T,
216 ) -> T {
217 if let LintLevel::Explicit(hir_id) = new_lint_level {
218 let old_lint_level = self.lint_level;
219 self.lint_level = hir_id;
220 let ret = f(self);
221 self.lint_level = old_lint_level;
222 ret
223 } else {
224 f(self)
225 }
226 }
227
228 fn visit_land(
231 &mut self,
232 ex: &'p Expr<'tcx>,
233 accumulator: &mut Vec<Option<(Span, RefutableFlag)>>,
234 ) -> Result<(), ErrorGuaranteed> {
235 match ex.kind {
236 ExprKind::Scope { value, lint_level, .. } => self.with_lint_level(lint_level, |this| {
237 this.visit_land(&this.thir[value], accumulator)
238 }),
239 ExprKind::LogicalOp { op: LogicalOp::And, lhs, rhs } => {
240 let res_lhs = self.visit_land(&self.thir[lhs], accumulator);
242 let res_rhs = self.visit_land_rhs(&self.thir[rhs])?;
243 accumulator.push(res_rhs);
244 res_lhs
245 }
246 _ => {
247 let res = self.visit_land_rhs(ex)?;
248 accumulator.push(res);
249 Ok(())
250 }
251 }
252 }
253
254 fn visit_land_rhs(
258 &mut self,
259 ex: &'p Expr<'tcx>,
260 ) -> Result<Option<(Span, RefutableFlag)>, ErrorGuaranteed> {
261 match ex.kind {
262 ExprKind::Scope { value, lint_level, .. } => {
263 self.with_lint_level(lint_level, |this| this.visit_land_rhs(&this.thir[value]))
264 }
265 ExprKind::Let { box ref pat, expr } => {
266 let expr = &self.thir()[expr];
267 self.with_let_source(LetSource::None, |this| {
268 this.visit_expr(expr);
269 });
270 Ok(Some((ex.span, self.is_let_irrefutable(pat, Some(expr))?)))
271 }
272 _ => {
273 self.with_let_source(LetSource::None, |this| {
274 this.visit_expr(ex);
275 });
276 Ok(None)
277 }
278 }
279 }
280
281 fn lower_pattern(
282 &mut self,
283 cx: &PatCtxt<'p, 'tcx>,
284 pat: &'p Pat<'tcx>,
285 ) -> Result<&'p DeconstructedPat<'p, 'tcx>, ErrorGuaranteed> {
286 if let Err(err) = pat.pat_error_reported() {
287 self.error = Err(err);
288 Err(err)
289 } else {
290 let refutable = if cx.refutable { Refutable } else { Irrefutable };
292 let mut err = Ok(());
293 pat.walk_always(|pat| {
294 check_borrow_conflicts_in_at_patterns(self, pat);
295 check_for_bindings_named_same_as_variants(self, pat, refutable);
296 err = err.and(check_never_pattern(cx, pat));
297 });
298 err?;
299 Ok(self.pattern_arena.alloc(cx.lower_pat(pat)))
300 }
301 }
302
303 fn is_known_valid_scrutinee(&self, scrutinee: &Expr<'tcx>) -> bool {
306 use ExprKind::*;
307 match &scrutinee.kind {
308 Deref { .. } => false,
311 Field { lhs, .. } => {
313 let lhs = &self.thir()[*lhs];
314 match lhs.ty.kind() {
315 ty::Adt(def, _) if def.is_union() => false,
316 _ => self.is_known_valid_scrutinee(lhs),
317 }
318 }
319 Index { lhs, .. } => {
321 let lhs = &self.thir()[*lhs];
322 self.is_known_valid_scrutinee(lhs)
323 }
324
325 Scope { value, .. } => self.is_known_valid_scrutinee(&self.thir()[*value]),
327
328 NeverToAny { source }
330 | Cast { source }
331 | Use { source }
332 | PointerCoercion { source, .. }
333 | PlaceTypeAscription { source, .. }
334 | ValueTypeAscription { source, .. }
335 | PlaceUnwrapUnsafeBinder { source }
336 | ValueUnwrapUnsafeBinder { source }
337 | WrapUnsafeBinder { source } => self.is_known_valid_scrutinee(&self.thir()[*source]),
338
339 Become { .. }
341 | Break { .. }
342 | Continue { .. }
343 | ConstContinue { .. }
344 | Return { .. } => true,
345
346 Assign { .. } | AssignOp { .. } | InlineAsm { .. } | Let { .. } => true,
348
349 RawBorrow { .. }
351 | Adt { .. }
352 | Array { .. }
353 | Binary { .. }
354 | Block { .. }
355 | Borrow { .. }
356 | Box { .. }
357 | Call { .. }
358 | ByUse { .. }
359 | Closure { .. }
360 | ConstBlock { .. }
361 | ConstParam { .. }
362 | If { .. }
363 | Literal { .. }
364 | LogicalOp { .. }
365 | Loop { .. }
366 | LoopMatch { .. }
367 | Match { .. }
368 | NamedConst { .. }
369 | NonHirLiteral { .. }
370 | OffsetOf { .. }
371 | Repeat { .. }
372 | StaticRef { .. }
373 | ThreadLocalRef { .. }
374 | Tuple { .. }
375 | Unary { .. }
376 | UpvarRef { .. }
377 | VarRef { .. }
378 | ZstLiteral { .. }
379 | Yield { .. } => true,
380 }
381 }
382
383 fn new_cx(
384 &self,
385 refutability: RefutableFlag,
386 whole_match_span: Option<Span>,
387 scrutinee: Option<&Expr<'tcx>>,
388 scrut_span: Span,
389 ) -> PatCtxt<'p, 'tcx> {
390 let refutable = match refutability {
391 Irrefutable => false,
392 Refutable => true,
393 };
394 let known_valid_scrutinee =
397 scrutinee.map(|scrut| self.is_known_valid_scrutinee(scrut)).unwrap_or(true);
398 PatCtxt {
399 tcx: self.tcx,
400 typeck_results: self.typeck_results,
401 typing_env: self.typing_env,
402 module: self.tcx.parent_module(self.lint_level).to_def_id(),
403 dropless_arena: self.dropless_arena,
404 match_lint_level: self.lint_level,
405 whole_match_span,
406 scrut_span,
407 refutable,
408 known_valid_scrutinee,
409 }
410 }
411
412 fn analyze_patterns(
413 &mut self,
414 cx: &PatCtxt<'p, 'tcx>,
415 arms: &[MatchArm<'p, 'tcx>],
416 scrut_ty: Ty<'tcx>,
417 ) -> Result<UsefulnessReport<'p, 'tcx>, ErrorGuaranteed> {
418 let report =
419 rustc_pattern_analysis::rustc::analyze_match(&cx, &arms, scrut_ty).map_err(|err| {
420 self.error = Err(err);
421 err
422 })?;
423
424 for (arm, is_useful) in report.arm_usefulness.iter() {
426 if let Usefulness::Useful(redundant_subpats) = is_useful
427 && !redundant_subpats.is_empty()
428 {
429 let mut redundant_subpats = redundant_subpats.clone();
430 redundant_subpats.sort_unstable_by_key(|(pat, _)| pat.data().span);
432 for (pat, explanation) in redundant_subpats {
433 report_unreachable_pattern(cx, arm.arm_data, pat, &explanation, None)
434 }
435 }
436 }
437 Ok(report)
438 }
439
440 #[instrument(level = "trace", skip(self))]
441 fn check_let(&mut self, pat: &'p Pat<'tcx>, scrutinee: Option<ExprId>, span: Span) {
442 assert!(self.let_source != LetSource::None);
443 let scrut = scrutinee.map(|id| &self.thir[id]);
444 if let LetSource::PlainLet = self.let_source {
445 self.check_binding_is_irrefutable(pat, "local binding", scrut, Some(span))
446 } else {
447 let Ok(refutability) = self.is_let_irrefutable(pat, scrut) else { return };
448 if matches!(refutability, Irrefutable) {
449 report_irrefutable_let_patterns(
450 self.tcx,
451 self.lint_level,
452 self.let_source,
453 1,
454 span,
455 );
456 }
457 }
458 }
459
460 fn check_match(
461 &mut self,
462 scrut: ExprId,
463 arms: &[ArmId],
464 source: hir::MatchSource,
465 expr_span: Span,
466 ) {
467 let scrut = &self.thir[scrut];
468 let cx = self.new_cx(Refutable, Some(expr_span), Some(scrut), scrut.span);
469
470 let mut tarms = Vec::with_capacity(arms.len());
471 for &arm in arms {
472 let arm = &self.thir.arms[arm];
473 let got_error = self.with_lint_level(arm.lint_level, |this| {
474 let Ok(pat) = this.lower_pattern(&cx, &arm.pattern) else { return true };
475 let arm =
476 MatchArm { pat, arm_data: this.lint_level, has_guard: arm.guard.is_some() };
477 tarms.push(arm);
478 false
479 });
480 if got_error {
481 return;
482 }
483 }
484
485 let Ok(report) = self.analyze_patterns(&cx, &tarms, scrut.ty) else { return };
486
487 match source {
488 hir::MatchSource::ForLoopDesugar if arms.len() == 1 => {}
491 hir::MatchSource::ForLoopDesugar
492 | hir::MatchSource::Postfix
493 | hir::MatchSource::Normal
494 | hir::MatchSource::FormatArgs => {
495 let is_match_arm =
496 matches!(source, hir::MatchSource::Postfix | hir::MatchSource::Normal);
497 report_arm_reachability(&cx, &report, is_match_arm);
498 }
499 hir::MatchSource::AwaitDesugar | hir::MatchSource::TryDesugar(_) => {}
502 }
503
504 let witnesses = report.non_exhaustiveness_witnesses;
506 if !witnesses.is_empty() {
507 if source == hir::MatchSource::ForLoopDesugar
508 && let [_, snd_arm] = *arms
509 {
510 let pat = &self.thir[snd_arm].pattern;
512 debug_assert_eq!(pat.span.desugaring_kind(), Some(DesugaringKind::ForLoop));
514 let PatKind::Variant { ref subpatterns, .. } = pat.kind else { bug!() };
515 let [pat_field] = &subpatterns[..] else { bug!() };
516 self.check_binding_is_irrefutable(
517 &pat_field.pattern,
518 "`for` loop binding",
519 None,
520 None,
521 );
522 } else {
523 let braces_span = match source {
526 hir::MatchSource::Normal => scrut
527 .span
528 .find_ancestor_in_same_ctxt(expr_span)
529 .map(|scrut_span| scrut_span.shrink_to_hi().with_hi(expr_span.hi())),
530 hir::MatchSource::Postfix => {
531 scrut.span.find_ancestor_in_same_ctxt(expr_span).and_then(|scrut_span| {
534 let sm = self.tcx.sess.source_map();
535 let brace_span = sm.span_extend_to_next_char(scrut_span, '{', true);
536 if sm.span_to_snippet(sm.next_point(brace_span)).as_deref() == Ok("{") {
537 let sp = brace_span.shrink_to_hi().with_hi(expr_span.hi());
538 sm.span_extend_prev_while(sp, |c| c.is_whitespace()).ok()
540 } else {
541 None
542 }
543 })
544 }
545 hir::MatchSource::ForLoopDesugar
546 | hir::MatchSource::TryDesugar(_)
547 | hir::MatchSource::AwaitDesugar
548 | hir::MatchSource::FormatArgs => None,
549 };
550 self.error = Err(report_non_exhaustive_match(
551 &cx,
552 self.thir,
553 scrut.ty,
554 scrut.span,
555 witnesses,
556 arms,
557 braces_span,
558 ));
559 }
560 }
561 }
562
563 #[instrument(level = "trace", skip(self))]
564 fn check_let_chain(
565 &mut self,
566 chain_refutabilities: Vec<Option<(Span, RefutableFlag)>>,
567 whole_chain_span: Span,
568 ) {
569 assert!(self.let_source != LetSource::None);
570
571 if chain_refutabilities.iter().all(|r| matches!(*r, Some((_, Irrefutable)))) {
572 report_irrefutable_let_patterns(
574 self.tcx,
575 self.lint_level,
576 self.let_source,
577 chain_refutabilities.len(),
578 whole_chain_span,
579 );
580 return;
581 }
582
583 if let Some(until) =
584 chain_refutabilities.iter().position(|r| !matches!(*r, Some((_, Irrefutable))))
585 && until > 0
586 {
587 if !matches!(
597 self.let_source,
598 LetSource::WhileLet | LetSource::IfLetGuard | LetSource::ElseIfLet
599 ) {
600 let prefix = &chain_refutabilities[..until];
602 let span_start = prefix[0].unwrap().0;
603 let span_end = prefix.last().unwrap().unwrap().0;
604 let span = span_start.to(span_end);
605 let count = prefix.len();
606 self.tcx.emit_node_span_lint(
607 IRREFUTABLE_LET_PATTERNS,
608 self.lint_level,
609 span,
610 LeadingIrrefutableLetPatterns { count },
611 );
612 }
613 }
614
615 if let Some(from) =
616 chain_refutabilities.iter().rposition(|r| !matches!(*r, Some((_, Irrefutable))))
617 && from != (chain_refutabilities.len() - 1)
618 {
619 let suffix = &chain_refutabilities[from + 1..];
621 let span_start = suffix[0].unwrap().0;
622 let span_end = suffix.last().unwrap().unwrap().0;
623 let span = span_start.to(span_end);
624 let count = suffix.len();
625 self.tcx.emit_node_span_lint(
626 IRREFUTABLE_LET_PATTERNS,
627 self.lint_level,
628 span,
629 TrailingIrrefutableLetPatterns { count },
630 );
631 }
632 }
633
634 fn analyze_binding(
635 &mut self,
636 pat: &'p Pat<'tcx>,
637 refutability: RefutableFlag,
638 scrut: Option<&Expr<'tcx>>,
639 ) -> Result<(PatCtxt<'p, 'tcx>, UsefulnessReport<'p, 'tcx>), ErrorGuaranteed> {
640 let cx = self.new_cx(refutability, None, scrut, pat.span);
641 let pat = self.lower_pattern(&cx, pat)?;
642 let arms = [MatchArm { pat, arm_data: self.lint_level, has_guard: false }];
643 let report = self.analyze_patterns(&cx, &arms, pat.ty().inner())?;
644 Ok((cx, report))
645 }
646
647 fn is_let_irrefutable(
648 &mut self,
649 pat: &'p Pat<'tcx>,
650 scrut: Option<&Expr<'tcx>>,
651 ) -> Result<RefutableFlag, ErrorGuaranteed> {
652 let (cx, report) = self.analyze_binding(pat, Refutable, scrut)?;
653 report_arm_reachability(&cx, &report, false);
655 Ok(if report.non_exhaustiveness_witnesses.is_empty() { Irrefutable } else { Refutable })
658 }
659
660 #[instrument(level = "trace", skip(self))]
661 fn check_binding_is_irrefutable(
662 &mut self,
663 pat: &'p Pat<'tcx>,
664 origin: &str,
665 scrut: Option<&Expr<'tcx>>,
666 sp: Option<Span>,
667 ) {
668 let pattern_ty = pat.ty;
669
670 let Ok((cx, report)) = self.analyze_binding(pat, Irrefutable, scrut) else { return };
671 let witnesses = report.non_exhaustiveness_witnesses;
672 if witnesses.is_empty() {
673 return;
675 }
676
677 let inform = sp.is_some().then_some(Inform);
678 let mut let_suggestion = None;
679 let mut misc_suggestion = None;
680 let mut interpreted_as_const = None;
681 let mut interpreted_as_const_sugg = None;
682
683 let mut unpeeled_pat = pat;
686 while let PatKind::AscribeUserType { ref subpattern, .. } = unpeeled_pat.kind {
687 unpeeled_pat = subpattern;
688 }
689
690 if let PatKind::ExpandedConstant { def_id, .. } = unpeeled_pat.kind
691 && let DefKind::Const = self.tcx.def_kind(def_id)
692 && let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(pat.span)
693 && snippet.chars().all(|c| c.is_alphanumeric() || c == '_')
695 {
696 let span = self.tcx.def_span(def_id);
697 let variable = self.tcx.item_name(def_id).to_string();
698 interpreted_as_const = Some(InterpretedAsConst { span, variable: variable.clone() });
700 interpreted_as_const_sugg = Some(InterpretedAsConstSugg { span: pat.span, variable });
701 } else if let PatKind::Constant { .. } = unpeeled_pat.kind
702 && let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(pat.span)
703 {
704 if snippet.chars().all(|c| c.is_digit(10)) {
706 misc_suggestion = Some(MiscPatternSuggestion::AttemptedIntegerLiteral {
708 start_span: pat.span.shrink_to_lo(),
709 });
710 }
711 }
712
713 if let Some(span) = sp
714 && self.tcx.sess.source_map().is_span_accessible(span)
715 && interpreted_as_const.is_none()
716 && scrut.is_some()
717 {
718 let mut bindings = vec![];
719 pat.each_binding(|name, _, _, _| bindings.push(name));
720
721 let semi_span = span.shrink_to_hi();
722 let start_span = span.shrink_to_lo();
723 let end_span = semi_span.shrink_to_lo();
724 let count = witnesses.len();
725
726 let_suggestion = Some(if bindings.is_empty() {
727 SuggestLet::If { start_span, semi_span, count }
728 } else {
729 SuggestLet::Else { end_span, count }
730 });
731 };
732
733 let adt_defined_here = report_adt_defined_here(self.tcx, pattern_ty, &witnesses, false);
734
735 let witness_1_is_privately_uninhabited = if let Some(witness_1) = witnesses.get(0)
738 && let ty::Adt(adt, args) = witness_1.ty().kind()
739 && adt.is_enum()
740 && let Constructor::Variant(variant_index) = witness_1.ctor()
741 {
742 let variant_inhabited = adt
743 .variant(*variant_index)
744 .inhabited_predicate(self.tcx, *adt)
745 .instantiate(self.tcx, args);
746 variant_inhabited.apply(self.tcx, cx.typing_env, cx.module)
747 && !variant_inhabited.apply_ignore_module(self.tcx, cx.typing_env)
748 } else {
749 false
750 };
751
752 let witness_1 = cx.print_witness_pat(witnesses.get(0).unwrap());
753
754 self.error = Err(self.tcx.dcx().emit_err(PatternNotCovered {
755 span: pat.span,
756 origin,
757 uncovered: Uncovered::new(pat.span, &cx, witnesses),
758 inform,
759 interpreted_as_const,
760 interpreted_as_const_sugg,
761 witness_1_is_privately_uninhabited,
762 witness_1,
763 _p: (),
764 pattern_ty,
765 let_suggestion,
766 misc_suggestion,
767 adt_defined_here,
768 }));
769 }
770}
771
772fn check_borrow_conflicts_in_at_patterns<'tcx>(cx: &MatchVisitor<'_, 'tcx>, pat: &Pat<'tcx>) {
784 let PatKind::Binding { name, mode, ty, subpattern: Some(box ref sub), .. } = pat.kind else {
786 return;
787 };
788
789 let is_binding_by_move = |ty: Ty<'tcx>| !cx.tcx.type_is_copy_modulo_regions(cx.typing_env, ty);
790
791 let sess = cx.tcx.sess;
792
793 let mut_outer = match mode.0 {
795 ByRef::No if is_binding_by_move(ty) => {
796 let mut conflicts_ref = Vec::new();
798 sub.each_binding(|_, mode, _, span| {
799 if matches!(mode, ByRef::Yes(_)) {
800 conflicts_ref.push(span)
801 }
802 });
803 if !conflicts_ref.is_empty() {
804 sess.dcx().emit_err(BorrowOfMovedValue {
805 binding_span: pat.span,
806 conflicts_ref,
807 name: Ident::new(name, pat.span),
808 ty,
809 suggest_borrowing: Some(pat.span.shrink_to_lo()),
810 });
811 }
812 return;
813 }
814 ByRef::No => return,
815 ByRef::Yes(m) => m,
816 };
817
818 let mut conflicts_move = Vec::new();
821 let mut conflicts_mut_mut = Vec::new();
822 let mut conflicts_mut_ref = Vec::new();
823 sub.each_binding(|name, mode, ty, span| {
824 match mode {
825 ByRef::Yes(mut_inner) => match (mut_outer, mut_inner) {
826 (Mutability::Not, Mutability::Not) => {}
828 (Mutability::Mut, Mutability::Mut) => {
830 conflicts_mut_mut.push(Conflict::Mut { span, name })
831 }
832 (Mutability::Not, Mutability::Mut) => {
833 conflicts_mut_ref.push(Conflict::Mut { span, name })
834 }
835 (Mutability::Mut, Mutability::Not) => {
836 conflicts_mut_ref.push(Conflict::Ref { span, name })
837 }
838 },
839 ByRef::No if is_binding_by_move(ty) => {
840 conflicts_move.push(Conflict::Moved { span, name }) }
842 ByRef::No => {} }
844 });
845
846 let report_mut_mut = !conflicts_mut_mut.is_empty();
847 let report_mut_ref = !conflicts_mut_ref.is_empty();
848 let report_move_conflict = !conflicts_move.is_empty();
849
850 let mut occurrences = match mut_outer {
851 Mutability::Mut => vec![Conflict::Mut { span: pat.span, name }],
852 Mutability::Not => vec![Conflict::Ref { span: pat.span, name }],
853 };
854 occurrences.extend(conflicts_mut_mut);
855 occurrences.extend(conflicts_mut_ref);
856 occurrences.extend(conflicts_move);
857
858 if report_mut_mut {
860 sess.dcx().emit_err(MultipleMutBorrows { span: pat.span, occurrences });
862 } else if report_mut_ref {
863 match mut_outer {
865 Mutability::Mut => {
866 sess.dcx().emit_err(AlreadyMutBorrowed { span: pat.span, occurrences });
867 }
868 Mutability::Not => {
869 sess.dcx().emit_err(AlreadyBorrowed { span: pat.span, occurrences });
870 }
871 };
872 } else if report_move_conflict {
873 sess.dcx().emit_err(MovedWhileBorrowed { span: pat.span, occurrences });
875 }
876}
877
878fn check_for_bindings_named_same_as_variants(
879 cx: &MatchVisitor<'_, '_>,
880 pat: &Pat<'_>,
881 rf: RefutableFlag,
882) {
883 if let PatKind::Binding {
884 name,
885 mode: BindingMode(ByRef::No, Mutability::Not),
886 subpattern: None,
887 ty,
888 ..
889 } = pat.kind
890 && let ty::Adt(edef, _) = ty.peel_refs().kind()
891 && edef.is_enum()
892 && edef
893 .variants()
894 .iter()
895 .any(|variant| variant.name == name && variant.ctor_kind() == Some(CtorKind::Const))
896 {
897 let variant_count = edef.variants().len();
898 let ty_path = with_no_trimmed_paths!(cx.tcx.def_path_str(edef.did()));
899 cx.tcx.emit_node_span_lint(
900 BINDINGS_WITH_VARIANT_NAME,
901 cx.lint_level,
902 pat.span,
903 BindingsWithVariantName {
904 suggestion: if rf == Refutable || variant_count == 1 {
908 Some(pat.span)
909 } else {
910 None
911 },
912 ty_path,
913 name: Ident::new(name, pat.span),
914 },
915 )
916 }
917}
918
919fn check_never_pattern<'tcx>(
921 cx: &PatCtxt<'_, 'tcx>,
922 pat: &Pat<'tcx>,
923) -> Result<(), ErrorGuaranteed> {
924 if let PatKind::Never = pat.kind {
925 if !cx.is_uninhabited(pat.ty) {
926 return Err(cx.tcx.dcx().emit_err(NonEmptyNeverPattern { span: pat.span, ty: pat.ty }));
927 }
928 }
929 Ok(())
930}
931
932fn report_irrefutable_let_patterns(
933 tcx: TyCtxt<'_>,
934 id: HirId,
935 source: LetSource,
936 count: usize,
937 span: Span,
938) {
939 macro_rules! emit_diag {
940 ($lint:tt) => {{
941 tcx.emit_node_span_lint(IRREFUTABLE_LET_PATTERNS, id, span, $lint { count });
942 }};
943 }
944
945 match source {
946 LetSource::None | LetSource::PlainLet | LetSource::Else => bug!(),
947 LetSource::IfLet | LetSource::ElseIfLet => emit_diag!(IrrefutableLetPatternsIfLet),
948 LetSource::IfLetGuard => emit_diag!(IrrefutableLetPatternsIfLetGuard),
949 LetSource::LetElse => emit_diag!(IrrefutableLetPatternsLetElse),
950 LetSource::WhileLet => emit_diag!(IrrefutableLetPatternsWhileLet),
951 }
952}
953
954fn report_unreachable_pattern<'p, 'tcx>(
956 cx: &PatCtxt<'p, 'tcx>,
957 hir_id: HirId,
958 pat: &DeconstructedPat<'p, 'tcx>,
959 explanation: &RedundancyExplanation<'p, 'tcx>,
960 whole_arm_span: Option<Span>,
961) {
962 static CAP_COVERED_BY_MANY: usize = 4;
963 let pat_span = pat.data().span;
964 let mut lint = UnreachablePattern {
965 span: Some(pat_span),
966 matches_no_values: None,
967 matches_no_values_ty: **pat.ty(),
968 uninhabited_note: None,
969 covered_by_catchall: None,
970 covered_by_one: None,
971 covered_by_many: None,
972 covered_by_many_n_more_count: 0,
973 wanted_constant: None,
974 accessible_constant: None,
975 inaccessible_constant: None,
976 pattern_let_binding: None,
977 suggest_remove: None,
978 };
979 match explanation.covered_by.as_slice() {
980 [] => {
981 lint.span = None; lint.uninhabited_note = Some(()); lint.matches_no_values = Some(pat_span);
985 lint.suggest_remove = whole_arm_span; pat.walk(&mut |subpat| {
987 let ty = **subpat.ty();
988 if cx.is_uninhabited(ty) {
989 lint.matches_no_values_ty = ty;
990 false } else if matches!(subpat.ctor(), Constructor::Ref | Constructor::UnionField) {
992 false } else {
994 true
995 }
996 });
997 }
998 [covering_pat] if pat_is_catchall(covering_pat) => {
999 let pat = covering_pat.data();
1001 lint.covered_by_catchall = Some(pat.span);
1002 find_fallback_pattern_typo(cx, hir_id, pat, &mut lint);
1003 }
1004 [covering_pat] => {
1005 lint.covered_by_one = Some(covering_pat.data().span);
1006 }
1007 covering_pats => {
1008 let mut iter = covering_pats.iter();
1009 let mut multispan = MultiSpan::from_span(pat_span);
1010 for p in iter.by_ref().take(CAP_COVERED_BY_MANY) {
1011 multispan.push_span_label(
1012 p.data().span,
1013 fluent::mir_build_unreachable_matches_same_values,
1014 );
1015 }
1016 let remain = iter.count();
1017 if remain == 0 {
1018 multispan.push_span_label(
1019 pat_span,
1020 fluent::mir_build_unreachable_making_this_unreachable,
1021 );
1022 } else {
1023 lint.covered_by_many_n_more_count = remain;
1024 multispan.push_span_label(
1025 pat_span,
1026 fluent::mir_build_unreachable_making_this_unreachable_n_more,
1027 );
1028 }
1029 lint.covered_by_many = Some(multispan);
1030 }
1031 }
1032 cx.tcx.emit_node_span_lint(UNREACHABLE_PATTERNS, hir_id, pat_span, lint);
1033}
1034
1035fn find_fallback_pattern_typo<'tcx>(
1037 cx: &PatCtxt<'_, 'tcx>,
1038 hir_id: HirId,
1039 pat: &Pat<'tcx>,
1040 lint: &mut UnreachablePattern<'_>,
1041) {
1042 if let Level::Allow = cx.tcx.lint_level_at_node(UNREACHABLE_PATTERNS, hir_id).level {
1043 return;
1046 }
1047 if let PatKind::Binding { name, subpattern: None, ty, .. } = pat.kind {
1048 let mut accessible = vec![];
1050 let mut accessible_path = vec![];
1051 let mut inaccessible = vec![];
1052 let mut imported = vec![];
1053 let mut imported_spans = vec![];
1054 let (infcx, param_env) = cx.tcx.infer_ctxt().build_with_typing_env(cx.typing_env);
1055 let parent = cx.tcx.hir_get_parent_item(hir_id);
1056
1057 for item in cx.tcx.hir_crate_items(()).free_items() {
1058 if let DefKind::Use = cx.tcx.def_kind(item.owner_id) {
1059 let item = cx.tcx.hir_expect_item(item.owner_id.def_id);
1061 let hir::ItemKind::Use(path, _) = item.kind else {
1062 continue;
1063 };
1064 if let Some(value_ns) = path.res.value_ns
1065 && let Res::Def(DefKind::Const, id) = value_ns
1066 && infcx.can_eq(param_env, ty, cx.tcx.type_of(id).instantiate_identity())
1067 {
1068 if cx.tcx.visibility(id).is_accessible_from(parent, cx.tcx) {
1069 let item_name = cx.tcx.item_name(id);
1071 accessible.push(item_name);
1072 accessible_path.push(with_no_trimmed_paths!(cx.tcx.def_path_str(id)));
1073 } else if cx.tcx.visibility(item.owner_id).is_accessible_from(parent, cx.tcx) {
1074 let ident = item.kind.ident().unwrap();
1077 imported.push(ident.name);
1078 imported_spans.push(ident.span);
1079 }
1080 }
1081 }
1082 if let DefKind::Const = cx.tcx.def_kind(item.owner_id)
1083 && infcx.can_eq(param_env, ty, cx.tcx.type_of(item.owner_id).instantiate_identity())
1084 {
1085 let item_name = cx.tcx.item_name(item.owner_id.into());
1087 let vis = cx.tcx.visibility(item.owner_id);
1088 if vis.is_accessible_from(parent, cx.tcx) {
1089 accessible.push(item_name);
1090 let path = with_no_trimmed_paths!(cx.tcx.def_path_str(item.owner_id));
1097 accessible_path.push(path);
1098 } else if name == item_name {
1099 inaccessible.push(cx.tcx.def_span(item.owner_id));
1102 }
1103 }
1104 }
1105 if let Some((i, &const_name)) =
1106 accessible.iter().enumerate().find(|&(_, &const_name)| const_name == name)
1107 {
1108 lint.wanted_constant = Some(WantedConstant {
1110 span: pat.span,
1111 is_typo: false,
1112 const_name: const_name.to_string(),
1113 const_path: accessible_path[i].clone(),
1114 });
1115 } else if let Some(name) = find_best_match_for_name(&accessible, name, None) {
1116 lint.wanted_constant = Some(WantedConstant {
1118 span: pat.span,
1119 is_typo: true,
1120 const_name: name.to_string(),
1121 const_path: name.to_string(),
1122 });
1123 } else if let Some(i) =
1124 imported.iter().enumerate().find(|&(_, &const_name)| const_name == name).map(|(i, _)| i)
1125 {
1126 lint.accessible_constant = Some(imported_spans[i]);
1129 } else if let Some(name) = find_best_match_for_name(&imported, name, None) {
1130 lint.wanted_constant = Some(WantedConstant {
1133 span: pat.span,
1134 is_typo: true,
1135 const_path: name.to_string(),
1136 const_name: name.to_string(),
1137 });
1138 } else if !inaccessible.is_empty() {
1139 for span in inaccessible {
1140 lint.inaccessible_constant = Some(span);
1142 }
1143 } else {
1144 for (_, node) in cx.tcx.hir_parent_iter(hir_id) {
1147 match node {
1148 hir::Node::Stmt(hir::Stmt { kind: hir::StmtKind::Let(let_stmt), .. }) => {
1149 if let hir::PatKind::Binding(_, _, binding_name, _) = let_stmt.pat.kind {
1150 if name == binding_name.name {
1151 lint.pattern_let_binding = Some(binding_name.span);
1152 }
1153 }
1154 }
1155 hir::Node::Block(hir::Block { stmts, .. }) => {
1156 for stmt in *stmts {
1157 if let hir::StmtKind::Let(let_stmt) = stmt.kind {
1158 if let hir::PatKind::Binding(_, _, binding_name, _) =
1159 let_stmt.pat.kind
1160 {
1161 if name == binding_name.name {
1162 lint.pattern_let_binding = Some(binding_name.span);
1163 }
1164 }
1165 }
1166 }
1167 }
1168 hir::Node::Item(_) => break,
1169 _ => {}
1170 }
1171 }
1172 }
1173 }
1174}
1175
1176fn report_arm_reachability<'p, 'tcx>(
1178 cx: &PatCtxt<'p, 'tcx>,
1179 report: &UsefulnessReport<'p, 'tcx>,
1180 is_match_arm: bool,
1181) {
1182 let sm = cx.tcx.sess.source_map();
1183 for (arm, is_useful) in report.arm_usefulness.iter() {
1184 if let Usefulness::Redundant(explanation) = is_useful {
1185 let hir_id = arm.arm_data;
1186 let arm_span = cx.tcx.hir_span(hir_id);
1187 let whole_arm_span = if is_match_arm {
1188 let with_whitespace = sm.span_extend_while_whitespace(arm_span);
1190 if let Some(comma) = sm.span_look_ahead(with_whitespace, ",", Some(1)) {
1191 Some(arm_span.to(comma))
1192 } else {
1193 Some(arm_span)
1194 }
1195 } else {
1196 None
1197 };
1198 report_unreachable_pattern(cx, hir_id, arm.pat, explanation, whole_arm_span)
1199 }
1200 }
1201}
1202
1203fn pat_is_catchall(pat: &DeconstructedPat<'_, '_>) -> bool {
1205 match pat.ctor() {
1206 Constructor::Wildcard => true,
1207 Constructor::Struct | Constructor::Ref => {
1208 pat.iter_fields().all(|ipat| pat_is_catchall(&ipat.pat))
1209 }
1210 _ => false,
1211 }
1212}
1213
1214fn report_non_exhaustive_match<'p, 'tcx>(
1216 cx: &PatCtxt<'p, 'tcx>,
1217 thir: &Thir<'tcx>,
1218 scrut_ty: Ty<'tcx>,
1219 sp: Span,
1220 witnesses: Vec<WitnessPat<'p, 'tcx>>,
1221 arms: &[ArmId],
1222 braces_span: Option<Span>,
1223) -> ErrorGuaranteed {
1224 let is_empty_match = arms.is_empty();
1225 let non_empty_enum = match scrut_ty.kind() {
1226 ty::Adt(def, _) => def.is_enum() && !def.variants().is_empty(),
1227 _ => false,
1228 };
1229 if is_empty_match && !non_empty_enum {
1232 return cx.tcx.dcx().emit_err(NonExhaustivePatternsTypeNotEmpty {
1233 cx,
1234 scrut_span: sp,
1235 braces_span,
1236 ty: scrut_ty,
1237 });
1238 }
1239
1240 let joined_patterns = joined_uncovered_patterns(cx, &witnesses);
1242 let mut err = struct_span_code_err!(
1243 cx.tcx.dcx(),
1244 sp,
1245 E0004,
1246 "non-exhaustive patterns: {joined_patterns} not covered"
1247 );
1248 err.span_label(
1249 sp,
1250 format!(
1251 "pattern{} {} not covered",
1252 rustc_errors::pluralize!(witnesses.len()),
1253 joined_patterns
1254 ),
1255 );
1256
1257 if let Some(AdtDefinedHere { adt_def_span, ty, variants }) =
1259 report_adt_defined_here(cx.tcx, scrut_ty, &witnesses, true)
1260 {
1261 let mut multi_span = MultiSpan::from_span(adt_def_span);
1262 multi_span.push_span_label(adt_def_span, "");
1263 for Variant { span } in variants {
1264 multi_span.push_span_label(span, "not covered");
1265 }
1266 err.span_note(multi_span, format!("`{ty}` defined here"));
1267 }
1268 err.note(format!("the matched value is of type `{}`", scrut_ty));
1269
1270 if !is_empty_match {
1271 let mut special_tys = FxIndexSet::default();
1272 collect_special_tys(cx, &witnesses[0], &mut special_tys);
1274
1275 for ty in special_tys {
1276 if ty.is_ptr_sized_integral() {
1277 if ty.inner() == cx.tcx.types.usize {
1278 err.note(format!(
1279 "`{ty}` does not have a fixed maximum value, so half-open ranges are \
1280 necessary to match exhaustively",
1281 ));
1282 } else if ty.inner() == cx.tcx.types.isize {
1283 err.note(format!(
1284 "`{ty}` does not have fixed minimum and maximum values, so half-open \
1285 ranges are necessary to match exhaustively",
1286 ));
1287 }
1288 } else if ty.inner() == cx.tcx.types.str_ {
1289 err.note("`&str` cannot be matched exhaustively, so a wildcard `_` is necessary");
1290 } else if cx.is_foreign_non_exhaustive_enum(ty) {
1291 err.note(format!("`{ty}` is marked as non-exhaustive, so a wildcard `_` is necessary to match exhaustively"));
1292 } else if cx.is_uninhabited(ty.inner()) {
1293 err.note(format!("`{ty}` is uninhabited but is not being matched by value, so a wildcard `_` is required"));
1296 }
1297 }
1298 }
1299
1300 if let ty::Ref(_, sub_ty, _) = scrut_ty.kind() {
1301 if !sub_ty.is_inhabited_from(cx.tcx, cx.module, cx.typing_env) {
1302 err.note("references are always considered inhabited");
1303 }
1304 }
1305
1306 for &arm in arms {
1307 let arm = &thir.arms[arm];
1308 if let PatKind::ExpandedConstant { def_id, .. } = arm.pattern.kind
1309 && !matches!(cx.tcx.def_kind(def_id), DefKind::InlineConst)
1310 && let Ok(snippet) = cx.tcx.sess.source_map().span_to_snippet(arm.pattern.span)
1311 && snippet.chars().all(|c| c.is_alphanumeric() || c == '_')
1313 {
1314 let const_name = cx.tcx.item_name(def_id);
1315 err.span_label(
1316 arm.pattern.span,
1317 format!(
1318 "this pattern doesn't introduce a new catch-all binding, but rather pattern \
1319 matches against the value of constant `{const_name}`",
1320 ),
1321 );
1322 err.span_note(cx.tcx.def_span(def_id), format!("constant `{const_name}` defined here"));
1323 err.span_suggestion_verbose(
1324 arm.pattern.span.shrink_to_hi(),
1325 "if you meant to introduce a binding, use a different name",
1326 "_var".to_string(),
1327 Applicability::MaybeIncorrect,
1328 );
1329 }
1330 }
1331
1332 let suggest_the_witnesses = witnesses.len() < 4;
1334 let suggested_arm = if suggest_the_witnesses {
1335 let pattern = witnesses
1336 .iter()
1337 .map(|witness| cx.print_witness_pat(witness))
1338 .collect::<Vec<String>>()
1339 .join(" | ");
1340 if witnesses.iter().all(|p| p.is_never_pattern()) && cx.tcx.features().never_patterns() {
1341 pattern
1343 } else {
1344 format!("{pattern} => todo!()")
1345 }
1346 } else {
1347 format!("_ => todo!()")
1348 };
1349 let mut suggestion = None;
1350 let sm = cx.tcx.sess.source_map();
1351 match arms {
1352 [] if let Some(braces_span) = braces_span => {
1353 let (indentation, more) = if let Some(snippet) = sm.indentation_before(sp) {
1355 (format!("\n{snippet}"), " ")
1356 } else {
1357 (" ".to_string(), "")
1358 };
1359 suggestion = Some((
1360 braces_span,
1361 format!(" {{{indentation}{more}{suggested_arm},{indentation}}}",),
1362 ));
1363 }
1364 [only] => {
1365 let only = &thir[*only];
1366 let (pre_indentation, is_multiline) = if let Some(snippet) =
1367 sm.indentation_before(only.span)
1368 && let Ok(with_trailing) =
1369 sm.span_extend_while(only.span, |c| c.is_whitespace() || c == ',')
1370 && sm.is_multiline(with_trailing)
1371 {
1372 (format!("\n{snippet}"), true)
1373 } else {
1374 (" ".to_string(), false)
1375 };
1376 let only_body = &thir[only.body];
1377 let comma = if matches!(only_body.kind, ExprKind::Block { .. })
1378 && only.span.eq_ctxt(only_body.span)
1379 && is_multiline
1380 {
1381 ""
1382 } else {
1383 ","
1384 };
1385 suggestion = Some((
1386 only.span.shrink_to_hi(),
1387 format!("{comma}{pre_indentation}{suggested_arm}"),
1388 ));
1389 }
1390 [.., prev, last] => {
1391 let prev = &thir[*prev];
1392 let last = &thir[*last];
1393 if prev.span.eq_ctxt(last.span) {
1394 let last_body = &thir[last.body];
1395 let comma = if matches!(last_body.kind, ExprKind::Block { .. })
1396 && last.span.eq_ctxt(last_body.span)
1397 {
1398 ""
1399 } else {
1400 ","
1401 };
1402 let spacing = if sm.is_multiline(prev.span.between(last.span)) {
1403 sm.indentation_before(last.span).map(|indent| format!("\n{indent}"))
1404 } else {
1405 Some(" ".to_string())
1406 };
1407 if let Some(spacing) = spacing {
1408 suggestion = Some((
1409 last.span.shrink_to_hi(),
1410 format!("{comma}{spacing}{suggested_arm}"),
1411 ));
1412 }
1413 }
1414 }
1415 _ => {}
1416 }
1417
1418 let msg = format!(
1419 "ensure that all possible cases are being handled by adding a match arm with a wildcard \
1420 pattern{}{}",
1421 if witnesses.len() > 1 && suggest_the_witnesses && suggestion.is_some() {
1422 ", a match arm with multiple or-patterns"
1423 } else {
1424 ""
1426 },
1427 match witnesses.len() {
1428 0 if suggestion.is_some() => " as shown",
1430 0 => "",
1431 1 if suggestion.is_some() => " or an explicit pattern as shown",
1432 1 => " or an explicit pattern",
1433 _ if suggestion.is_some() => " as shown, or multiple match arms",
1434 _ => " or multiple match arms",
1435 },
1436 );
1437
1438 let all_arms_have_guards = arms.iter().all(|arm_id| thir[*arm_id].guard.is_some());
1439 if !is_empty_match && all_arms_have_guards {
1440 err.subdiagnostic(NonExhaustiveMatchAllArmsGuarded);
1441 }
1442 if let Some((span, sugg)) = suggestion {
1443 err.span_suggestion_verbose(span, msg, sugg, Applicability::HasPlaceholders);
1444 } else {
1445 err.help(msg);
1446 }
1447 err.emit()
1448}
1449
1450fn joined_uncovered_patterns<'p, 'tcx>(
1451 cx: &PatCtxt<'p, 'tcx>,
1452 witnesses: &[WitnessPat<'p, 'tcx>],
1453) -> String {
1454 const LIMIT: usize = 3;
1455 let pat_to_str = |pat: &WitnessPat<'p, 'tcx>| cx.print_witness_pat(pat);
1456 match witnesses {
1457 [] => bug!(),
1458 [witness] => format!("`{}`", cx.print_witness_pat(witness)),
1459 [head @ .., tail] if head.len() < LIMIT => {
1460 let head: Vec<_> = head.iter().map(pat_to_str).collect();
1461 format!("`{}` and `{}`", head.join("`, `"), cx.print_witness_pat(tail))
1462 }
1463 _ => {
1464 let (head, tail) = witnesses.split_at(LIMIT);
1465 let head: Vec<_> = head.iter().map(pat_to_str).collect();
1466 format!("`{}` and {} more", head.join("`, `"), tail.len())
1467 }
1468 }
1469}
1470
1471fn collect_special_tys<'tcx>(
1473 cx: &PatCtxt<'_, 'tcx>,
1474 pat: &WitnessPat<'_, 'tcx>,
1475 special_tys: &mut FxIndexSet<RevealedTy<'tcx>>,
1476) {
1477 if matches!(pat.ctor(), Constructor::NonExhaustive | Constructor::Never) {
1478 special_tys.insert(*pat.ty());
1479 }
1480 if let Constructor::IntRange(range) = pat.ctor() {
1481 if cx.is_range_beyond_boundaries(range, *pat.ty()) {
1482 special_tys.insert(*pat.ty());
1484 }
1485 }
1486 pat.iter_fields().for_each(|field_pat| collect_special_tys(cx, field_pat, special_tys))
1487}
1488
1489fn report_adt_defined_here<'tcx>(
1490 tcx: TyCtxt<'tcx>,
1491 ty: Ty<'tcx>,
1492 witnesses: &[WitnessPat<'_, 'tcx>],
1493 point_at_non_local_ty: bool,
1494) -> Option<AdtDefinedHere<'tcx>> {
1495 let ty = ty.peel_refs();
1496 let ty::Adt(def, _) = ty.kind() else {
1497 return None;
1498 };
1499 let adt_def_span =
1500 tcx.hir_get_if_local(def.did()).and_then(|node| node.ident()).map(|ident| ident.span);
1501 let adt_def_span = if point_at_non_local_ty {
1502 adt_def_span.unwrap_or_else(|| tcx.def_span(def.did()))
1503 } else {
1504 adt_def_span?
1505 };
1506
1507 let mut variants = vec![];
1508 for span in maybe_point_at_variant(tcx, *def, witnesses.iter().take(5)) {
1509 variants.push(Variant { span });
1510 }
1511 Some(AdtDefinedHere { adt_def_span, ty, variants })
1512}
1513
1514fn maybe_point_at_variant<'a, 'p: 'a, 'tcx: 'p>(
1515 tcx: TyCtxt<'tcx>,
1516 def: AdtDef<'tcx>,
1517 patterns: impl Iterator<Item = &'a WitnessPat<'p, 'tcx>>,
1518) -> Vec<Span> {
1519 let mut covered = vec![];
1520 for pattern in patterns {
1521 if let Constructor::Variant(variant_index) = pattern.ctor() {
1522 if let ty::Adt(this_def, _) = pattern.ty().kind()
1523 && this_def.did() != def.did()
1524 {
1525 continue;
1526 }
1527 let sp = def.variant(*variant_index).ident(tcx).span;
1528 if covered.contains(&sp) {
1529 continue;
1532 }
1533 covered.push(sp);
1534 }
1535 covered.extend(maybe_point_at_variant(tcx, def, pattern.iter_fields()));
1536 }
1537 covered
1538}