rustc_mir_build/thir/pattern/
check_match.rs

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        // FIXME(#132279): We're in a body, should handle opaques.
45        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        // other types of MIR don't have function parameters, and we don't need to
58        // categorize those for the irrefutable check.
59        _ 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    /// Tracks if we encountered an error while checking this body. That the first function to
100    /// report it stores it here. Some functions return `Result` to allow callers to short-circuit
101    /// on error, but callers don't need to store it here again.
102    error: Result<(), ErrorGuaranteed>,
103}
104
105// Visitor for a thir body. This calls `check_match`, `check_let` and `check_let_chain` as
106// appropriate.
107impl<'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                // Give a specific `let_source` for the condition.
136                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 at least one of the operands is a `let ... = ...`.
172                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    /// Visit a nested chain of `&&`. Used for if-let chains. This must call `visit_expr` on the
229    /// subexpressions we are not handling ourselves.
230    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                // We recurse into the lhs only, because `&&` chains associate to the left.
241                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    /// Visit the right-hand-side of a `&&`. Used for if-let chains. Returns `Some` if the
255    /// expression was ultimately a `let ... = ...`, and `None` if it was a normal boolean
256    /// expression. This must call `visit_expr` on the subexpressions we are not handling ourselves.
257    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            // Check the pattern for some things unrelated to exhaustiveness.
291            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    /// Inspects the match scrutinee expression to determine whether the place it evaluates to may
304    /// hold invalid data.
305    fn is_known_valid_scrutinee(&self, scrutinee: &Expr<'tcx>) -> bool {
306        use ExprKind::*;
307        match &scrutinee.kind {
308            // Pointers can validly point to a place with invalid data. It is undecided whether
309            // references can too, so we conservatively assume they can.
310            Deref { .. } => false,
311            // Inherit validity of the parent place, unless the parent is an union.
312            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            // Essentially a field access.
320            Index { lhs, .. } => {
321                let lhs = &self.thir()[*lhs];
322                self.is_known_valid_scrutinee(lhs)
323            }
324
325            // No-op.
326            Scope { value, .. } => self.is_known_valid_scrutinee(&self.thir()[*value]),
327
328            // Casts don't cause a load.
329            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            // These diverge.
340            Become { .. }
341            | Break { .. }
342            | Continue { .. }
343            | ConstContinue { .. }
344            | Return { .. } => true,
345
346            // These are statements that evaluate to `()`.
347            Assign { .. } | AssignOp { .. } | InlineAsm { .. } | Let { .. } => true,
348
349            // These evaluate to a value.
350            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        // If we don't have a scrutinee we're either a function parameter or a `let x;`. Both cases
395        // require validity.
396        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        // Warn unreachable subpatterns.
425        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                // Emit lints in the order in which they occur in the file.
431                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            // Don't report arm reachability of desugared `match $iter.into_iter() { iter => .. }`
489            // when the iterator is an uninhabited type. unreachable_code will trigger instead.
490            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            // Unreachable patterns in try and await expressions occur when one of
500            // the arms are an uninhabited type. Which is OK.
501            hir::MatchSource::AwaitDesugar | hir::MatchSource::TryDesugar(_) => {}
502        }
503
504        // Check if the match is exhaustive.
505        let witnesses = report.non_exhaustiveness_witnesses;
506        if !witnesses.is_empty() {
507            if source == hir::MatchSource::ForLoopDesugar
508                && let [_, snd_arm] = *arms
509            {
510                // the for loop pattern is not irrefutable
511                let pat = &self.thir[snd_arm].pattern;
512                // `pat` should be `Some(<pat_field>)` from a desugared for loop.
513                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                // span after scrutinee, or after `.match`. That is, the braces, arms,
524                // and any whitespace preceding the braces.
525                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                        // This is horrendous, and we should deal with it by just
532                        // stashing the span of the braces somewhere (like in the match source).
533                        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                                // We also need to extend backwards for whitespace
539                                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            // The entire chain is made up of irrefutable `let` statements
573            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            // The chain has a non-zero prefix of irrefutable `let` statements.
588
589            // Check if the let source is while, for there is no alternative place to put a prefix,
590            // and we shouldn't lint.
591            // For let guards inside a match, prefixes might use bindings of the match pattern,
592            // so can't always be moved out.
593            // For `else if let`, an extra indentation level would be required to move the bindings.
594            // FIXME: Add checking whether the bindings are actually used in the prefix,
595            // and lint if they are not.
596            if !matches!(
597                self.let_source,
598                LetSource::WhileLet | LetSource::IfLetGuard | LetSource::ElseIfLet
599            ) {
600                // Emit the lint
601                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            // The chain has a non-empty suffix of irrefutable `let` statements
620            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 if the pattern is unreachable, which can only occur when the type is uninhabited.
654        report_arm_reachability(&cx, &report, false);
655        // If the list of witnesses is empty, the match is exhaustive, i.e. the `if let` pattern is
656        // irrefutable.
657        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            // The pattern is irrefutable.
674            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        // These next few matches want to peek through `AscribeUserType` to see
684        // the underlying pattern.
685        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            // We filter out paths with multiple path::segments.
694            && 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            // When we encounter a constant as the binding name, point at the `const` definition.
699            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 the pattern to match is an integer literal:
705            if snippet.chars().all(|c| c.is_digit(10)) {
706                // Then give a suggestion, the user might've meant to create a binding instead.
707                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        // Emit an extra note if the first uncovered witness would be uninhabited
736        // if we disregard visibility.
737        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
772/// Check if a by-value binding is by-value. That is, check if the binding's type is not `Copy`.
773/// Check that there are no borrow or move conflicts in `binding @ subpat` patterns.
774///
775/// For example, this would reject:
776/// - `ref x @ Some(ref mut y)`,
777/// - `ref mut x @ Some(ref y)`,
778/// - `ref mut x @ Some(ref mut y)`,
779/// - `ref mut? x @ Some(y)`, and
780/// - `x @ Some(ref mut? y)`.
781///
782/// This analysis is *not* subsumed by NLL.
783fn check_borrow_conflicts_in_at_patterns<'tcx>(cx: &MatchVisitor<'_, 'tcx>, pat: &Pat<'tcx>) {
784    // Extract `sub` in `binding @ sub`.
785    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    // Get the binding move, extract the mutability if by-ref.
794    let mut_outer = match mode.0 {
795        ByRef::No if is_binding_by_move(ty) => {
796            // We have `x @ pat` where `x` is by-move. Reject all borrows in `pat`.
797            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    // We now have `ref $mut_outer binding @ sub` (semantically).
819    // Recurse into each binding in `sub` and find mutability or move conflicts.
820    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                // Both sides are `ref`.
827                (Mutability::Not, Mutability::Not) => {}
828                // 2x `ref mut`.
829                (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 }) // `ref mut?` + by-move conflict.
841            }
842            ByRef::No => {} // `ref mut?` + by-copy is fine.
843        }
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    // Report errors if any.
859    if report_mut_mut {
860        // Report mutability conflicts for e.g. `ref mut x @ Some(ref mut y)`.
861        sess.dcx().emit_err(MultipleMutBorrows { span: pat.span, occurrences });
862    } else if report_mut_ref {
863        // Report mutability conflicts for e.g. `ref x @ Some(ref mut y)` or the converse.
864        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        // Report by-ref and by-move conflicts, e.g. `ref x @ y`.
874        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                // If this is an irrefutable pattern, and there's > 1 variant,
905                // then we can't actually match on this. Applying the below
906                // suggestion would produce code that breaks on `check_binding_is_irrefutable`.
907                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
919/// Check that never patterns are only used on inhabited types.
920fn 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
954/// Report unreachable arms, if any.
955fn 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            // Empty pattern; we report the uninhabited type that caused the emptiness.
982            lint.span = None; // Don't label the pattern itself
983            lint.uninhabited_note = Some(()); // Give a link about empty types
984            lint.matches_no_values = Some(pat_span);
985            lint.suggest_remove = whole_arm_span; // Suggest to remove the match arm
986            pat.walk(&mut |subpat| {
987                let ty = **subpat.ty();
988                if cx.is_uninhabited(ty) {
989                    lint.matches_no_values_ty = ty;
990                    false // No need to dig further.
991                } else if matches!(subpat.ctor(), Constructor::Ref | Constructor::UnionField) {
992                    false // Don't explore further since they are not by-value.
993                } else {
994                    true
995                }
996            });
997        }
998        [covering_pat] if pat_is_catchall(covering_pat) => {
999            // A binding pattern that matches all, a single binding name.
1000            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
1035/// Detect typos that were meant to be a `const` but were interpreted as a new pattern binding.
1036fn 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        // This is because we use `with_no_trimmed_paths` later, so if we never emit the lint we'd
1044        // ICE. At the same time, we don't really need to do all of this if we won't emit anything.
1045        return;
1046    }
1047    if let PatKind::Binding { name, subpattern: None, ty, .. } = pat.kind {
1048        // See if the binding might have been a `const` that was mistyped or out of scope.
1049        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                // Look for consts being re-exported.
1060                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                        // The original const is accessible, suggest using it directly.
1070                        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                        // The const is accessible only through the re-export, point at
1075                        // the `use`.
1076                        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                // Look for local consts.
1086                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                    // FIXME: the line below from PR #135310 is a workaround for the ICE in issue
1091                    // #135289, where a macro in a dependency can create unreachable patterns in the
1092                    // current crate. Path trimming expects diagnostics for a typoed const, but no
1093                    // diagnostics are emitted and we ICE. See
1094                    // `tests/ui/resolve/const-with-typo-in-pattern-binding-ice-135289.rs` for a
1095                    // test that reproduces the ICE if we don't use `with_no_trimmed_paths!`.
1096                    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                    // The const exists somewhere in this crate, but it can't be imported
1100                    // from this pattern's scope. We'll just point at its definition.
1101                    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            // The pattern name is an exact match, so the pattern needed to be imported.
1109            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            // The pattern name is likely a typo.
1117            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            // The const with the exact name wasn't re-exported from an import in this
1127            // crate, we point at the import.
1128            lint.accessible_constant = Some(imported_spans[i]);
1129        } else if let Some(name) = find_best_match_for_name(&imported, name, None) {
1130            // The typoed const wasn't re-exported by an import in this crate, we suggest
1131            // the right name (which will likely require another follow up suggestion).
1132            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                // The const with the exact name match isn't accessible, we just point at it.
1141                lint.inaccessible_constant = Some(span);
1142            }
1143        } else {
1144            // Look for local bindings for people that might have gotten confused with how
1145            // `let` and `const` works.
1146            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
1176/// Report unreachable arms, if any.
1177fn 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                // If the arm is followed by a comma, extend the span to include it.
1189                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
1203/// Checks for common cases of "catchall" patterns that may not be intended as such.
1204fn 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
1214/// Report that a match is not exhaustive.
1215fn 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    // In the case of an empty match, replace the '`_` not covered' diagnostic with something more
1230    // informative.
1231    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    // FIXME: migration of this diagnostic will require list support
1241    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    // Point at the definition of non-covered `enum` variants.
1258    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        // Look at the first witness.
1273        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                // The type is uninhabited yet there is a witness: we must be in the `MaybeInvalid`
1294                // case.
1295                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            // We filter out paths with multiple path::segments.
1312            && 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    // Whether we suggest the actual missing patterns or `_`.
1333    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            // Arms with a never pattern don't take a body.
1342            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            // Get the span for the empty match body `{}`.
1354            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            // we are either not suggesting anything, or suggesting `_`
1425            ""
1426        },
1427        match witnesses.len() {
1428            // non-exhaustive enum case
1429            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
1471/// Collect types that require specific explanations when they show up in witnesses.
1472fn 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            // The range denotes the values before `isize::MIN` or the values after `usize::MAX`/`isize::MAX`.
1483            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                // Don't point at variants that have already been covered due to other patterns to avoid
1530                // visual clutter.
1531                continue;
1532            }
1533            covered.push(sp);
1534        }
1535        covered.extend(maybe_point_at_variant(tcx, def, pattern.iter_fields()));
1536    }
1537    covered
1538}