compiler/rustc_typeck/src/check/pat.rs

   1 use crate::check::FnCtxt;
   2 use rustc_ast as ast;
   3
   4 use rustc_data_structures::fx::FxHashMap;
   5 use rustc_errors::{
   6     pluralize, struct_span_err, Applicability, Diagnostic, DiagnosticBuilder, ErrorGuaranteed,
   7 };
   8 use rustc_hir as hir;
   9 use rustc_hir::def::{CtorKind, DefKind, Res};
  10 use rustc_hir::pat_util::EnumerateAndAdjustIterator;
  11 use rustc_hir::{HirId, Pat, PatKind};
  12 use rustc_infer::infer;
  13 use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
  14 use rustc_middle::middle::stability::EvalResult;
  15 use rustc_middle::ty::{self, Adt, BindingMode, Ty, TypeFoldable};
  16 use rustc_session::lint::builtin::NON_EXHAUSTIVE_OMITTED_PATTERNS;
  17 use rustc_span::hygiene::DesugaringKind;
  18 use rustc_span::lev_distance::find_best_match_for_name;
  19 use rustc_span::source_map::{Span, Spanned};
  20 use rustc_span::symbol::{kw, sym, Ident};
  21 use rustc_span::{BytePos, MultiSpan, DUMMY_SP};
  22 use rustc_trait_selection::autoderef::Autoderef;
  23 use rustc_trait_selection::traits::{ObligationCause, Pattern};
  24 use ty::VariantDef;
  25
  26 use std::cmp;
  27 use std::collections::hash_map::Entry::{Occupied, Vacant};
  28
  29 use super::report_unexpected_variant_res;
  30
  31 const CANNOT_IMPLICITLY_DEREF_POINTER_TRAIT_OBJ: &str = "\
  32 This error indicates that a pointer to a trait type cannot be implicitly dereferenced by a \
  33 pattern. Every trait defines a type, but because the size of trait implementors isn't fixed, \
  34 this type has no compile-time size. Therefore, all accesses to trait types must be through \
  35 pointers. If you encounter this error you should try to avoid dereferencing the pointer.
  36
  37 You can read more about trait objects in the Trait Objects section of the Reference: \
  38 https://doc.rust-lang.org/reference/types.html#trait-objects";
  39
  40 /// Information about the expected type at the top level of type checking a pattern.
  41 ///
  42 /// **NOTE:** This is only for use by diagnostics. Do NOT use for type checking logic!
  43 #[derive(Copy, Clone)]
  44 struct TopInfo<'tcx> {
  45     /// The `expected` type at the top level of type checking a pattern.
  46     expected: Ty<'tcx>,
  47     /// Was the origin of the `span` from a scrutinee expression?
  48     ///
  49     /// Otherwise there is no scrutinee and it could be e.g. from the type of a formal parameter.
  50     origin_expr: bool,
  51     /// The span giving rise to the `expected` type, if one could be provided.
  52     ///
  53     /// If `origin_expr` is `true`, then this is the span of the scrutinee as in:
  54     ///
  55     /// - `match scrutinee { ... }`
  56     /// - `let _ = scrutinee;`
  57     ///
  58     /// This is used to point to add context in type errors.
  59     /// In the following example, `span` corresponds to the `a + b` expression:
  60     ///
  61     /// ```text
  62     /// error[E0308]: mismatched types
  63     ///  --> src/main.rs:L:C
  64     ///   |
  65     /// L |    let temp: usize = match a + b {
  66     ///   |                            ----- this expression has type `usize`
  67     /// L |         Ok(num) => num,
  68     ///   |         ^^^^^^^ expected `usize`, found enum `std::result::Result`
  69     ///   |
  70     ///   = note: expected type `usize`
  71     ///              found type `std::result::Result<_, _>`
  72     /// ```
  73     span: Option<Span>,
  74     /// This refers to the parent pattern. Used to provide extra diagnostic information on errors.
  75     /// ```text
  76     /// error[E0308]: mismatched types
  77     ///   --> $DIR/const-in-struct-pat.rs:8:17
  78     ///   |
  79     /// L | struct f;
  80     ///   | --------- unit struct defined here
  81     /// ...
  82     /// L |     let Thing { f } = t;
  83     ///   |                 ^
  84     ///   |                 |
  85     ///   |                 expected struct `std::string::String`, found struct `f`
  86     ///   |                 `f` is interpreted as a unit struct, not a new binding
  87     ///   |                 help: bind the struct field to a different name instead: `f: other_f`
  88     /// ```
  89     parent_pat: Option<&'tcx Pat<'tcx>>,
  90 }
  91
  92 impl<'tcx> FnCtxt<'_, 'tcx> {
  93     fn pattern_cause(&self, ti: TopInfo<'tcx>, cause_span: Span) -> ObligationCause<'tcx> {
  94         let code = Pattern { span: ti.span, root_ty: ti.expected, origin_expr: ti.origin_expr };
  95         self.cause(cause_span, code)
  96     }
  97
  98     fn demand_eqtype_pat_diag(
  99         &self,
 100         cause_span: Span,
 101         expected: Ty<'tcx>,
 102         actual: Ty<'tcx>,
 103         ti: TopInfo<'tcx>,
 104     ) -> Option<DiagnosticBuilder<'tcx, ErrorGuaranteed>> {
 105         self.demand_eqtype_with_origin(&self.pattern_cause(ti, cause_span), expected, actual)
 106     }
 107
 108     fn demand_eqtype_pat(
 109         &self,
 110         cause_span: Span,
 111         expected: Ty<'tcx>,
 112         actual: Ty<'tcx>,
 113         ti: TopInfo<'tcx>,
 114     ) {
 115         if let Some(mut err) = self.demand_eqtype_pat_diag(cause_span, expected, actual, ti) {
 116             err.emit();
 117         }
 118     }
 119 }
 120
 121 const INITIAL_BM: BindingMode = BindingMode::BindByValue(hir::Mutability::Not);
 122
 123 /// Mode for adjusting the expected type and binding mode.
 124 enum AdjustMode {
 125     /// Peel off all immediate reference types.
 126     Peel,
 127     /// Reset binding mode to the initial mode.
 128     Reset,
 129     /// Pass on the input binding mode and expected type.
 130     Pass,
 131 }
 132
 133 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 134     /// Type check the given top level pattern against the `expected` type.
 135     ///
 136     /// If a `Some(span)` is provided and `origin_expr` holds,
 137     /// then the `span` represents the scrutinee's span.
 138     /// The scrutinee is found in e.g. `match scrutinee { ... }` and `let pat = scrutinee;`.
 139     ///
 140     /// Otherwise, `Some(span)` represents the span of a type expression
 141     /// which originated the `expected` type.
 142     pub fn check_pat_top(
 143         &self,
 144         pat: &'tcx Pat<'tcx>,
 145         expected: Ty<'tcx>,
 146         span: Option<Span>,
 147         origin_expr: bool,
 148     ) {
 149         let info = TopInfo { expected, origin_expr, span, parent_pat: None };
 150         self.check_pat(pat, expected, INITIAL_BM, info);
 151     }
 152
 153     /// Type check the given `pat` against the `expected` type
 154     /// with the provided `def_bm` (default binding mode).
 155     ///
 156     /// Outside of this module, `check_pat_top` should always be used.
 157     /// Conversely, inside this module, `check_pat_top` should never be used.
 158     #[instrument(level = "debug", skip(self, ti))]
 159     fn check_pat(
 160         &self,
 161         pat: &'tcx Pat<'tcx>,
 162         expected: Ty<'tcx>,
 163         def_bm: BindingMode,
 164         ti: TopInfo<'tcx>,
 165     ) {
 166         let path_res = match &pat.kind {
 167             PatKind::Path(qpath) => {
 168                 Some(self.resolve_ty_and_res_fully_qualified_call(qpath, pat.hir_id, pat.span))
 169             }
 170             _ => None,
 171         };
 172         let adjust_mode = self.calc_adjust_mode(pat, path_res.map(|(res, ..)| res));
 173         let (expected, def_bm) = self.calc_default_binding_mode(pat, expected, def_bm, adjust_mode);
 174
 175         let ty = match pat.kind {
 176             PatKind::Wild => expected,
 177             PatKind::Lit(lt) => self.check_pat_lit(pat.span, lt, expected, ti),
 178             PatKind::Range(lhs, rhs, _) => self.check_pat_range(pat.span, lhs, rhs, expected, ti),
 179             PatKind::Binding(ba, var_id, _, sub) => {
 180                 self.check_pat_ident(pat, ba, var_id, sub, expected, def_bm, ti)
 181             }
 182             PatKind::TupleStruct(ref qpath, subpats, ddpos) => {
 183                 self.check_pat_tuple_struct(pat, qpath, subpats, ddpos, expected, def_bm, ti)
 184             }
 185             PatKind::Path(_) => self.check_pat_path(pat, path_res.unwrap(), expected, ti),
 186             PatKind::Struct(ref qpath, fields, has_rest_pat) => {
 187                 self.check_pat_struct(pat, qpath, fields, has_rest_pat, expected, def_bm, ti)
 188             }
 189             PatKind::Or(pats) => {
 190                 let parent_pat = Some(pat);
 191                 for pat in pats {
 192                     self.check_pat(pat, expected, def_bm, TopInfo { parent_pat, ..ti });
 193                 }
 194                 expected
 195             }
 196             PatKind::Tuple(elements, ddpos) => {
 197                 self.check_pat_tuple(pat.span, elements, ddpos, expected, def_bm, ti)
 198             }
 199             PatKind::Box(inner) => self.check_pat_box(pat.span, inner, expected, def_bm, ti),
 200             PatKind::Ref(inner, mutbl) => {
 201                 self.check_pat_ref(pat, inner, mutbl, expected, def_bm, ti)
 202             }
 203             PatKind::Slice(before, slice, after) => {
 204                 self.check_pat_slice(pat.span, before, slice, after, expected, def_bm, ti)
 205             }
 206         };
 207
 208         self.write_ty(pat.hir_id, ty);
 209
 210         // (note_1): In most of the cases where (note_1) is referenced
 211         // (literals and constants being the exception), we relate types
 212         // using strict equality, even though subtyping would be sufficient.
 213         // There are a few reasons for this, some of which are fairly subtle
 214         // and which cost me (nmatsakis) an hour or two debugging to remember,
 215         // so I thought I'd write them down this time.
 216         //
 217         // 1. There is no loss of expressiveness here, though it does
 218         // cause some inconvenience. What we are saying is that the type
 219         // of `x` becomes *exactly* what is expected. This can cause unnecessary
 220         // errors in some cases, such as this one:
 221         //
 222         // ```
 223         // fn foo<'x>(x: &'x i32) {
 224         //    let a = 1;
 225         //    let mut z = x;
 226         //    z = &a;
 227         // }
 228         // ```
 229         //
 230         // The reason we might get an error is that `z` might be
 231         // assigned a type like `&'x i32`, and then we would have
 232         // a problem when we try to assign `&a` to `z`, because
 233         // the lifetime of `&a` (i.e., the enclosing block) is
 234         // shorter than `'x`.
 235         //
 236         // HOWEVER, this code works fine. The reason is that the
 237         // expected type here is whatever type the user wrote, not
 238         // the initializer's type. In this case the user wrote
 239         // nothing, so we are going to create a type variable `Z`.
 240         // Then we will assign the type of the initializer (`&'x i32`)
 241         // as a subtype of `Z`: `&'x i32 <: Z`. And hence we
 242         // will instantiate `Z` as a type `&'0 i32` where `'0` is
 243         // a fresh region variable, with the constraint that `'x : '0`.
 244         // So basically we're all set.
 245         //
 246         // Note that there are two tests to check that this remains true
 247         // (`regions-reassign-{match,let}-bound-pointer.rs`).
 248         //
 249         // 2. Things go horribly wrong if we use subtype. The reason for
 250         // THIS is a fairly subtle case involving bound regions. See the
 251         // `givens` field in `region_constraints`, as well as the test
 252         // `regions-relate-bound-regions-on-closures-to-inference-variables.rs`,
 253         // for details. Short version is that we must sometimes detect
 254         // relationships between specific region variables and regions
 255         // bound in a closure signature, and that detection gets thrown
 256         // off when we substitute fresh region variables here to enable
 257         // subtyping.
 258     }
 259
 260     /// Compute the new expected type and default binding mode from the old ones
 261     /// as well as the pattern form we are currently checking.
 262     fn calc_default_binding_mode(
 263         &self,
 264         pat: &'tcx Pat<'tcx>,
 265         expected: Ty<'tcx>,
 266         def_bm: BindingMode,
 267         adjust_mode: AdjustMode,
 268     ) -> (Ty<'tcx>, BindingMode) {
 269         match adjust_mode {
 270             AdjustMode::Pass => (expected, def_bm),
 271             AdjustMode::Reset => (expected, INITIAL_BM),
 272             AdjustMode::Peel => self.peel_off_references(pat, expected, def_bm),
 273         }
 274     }
 275
 276     /// How should the binding mode and expected type be adjusted?
 277     ///
 278     /// When the pattern is a path pattern, `opt_path_res` must be `Some(res)`.
 279     fn calc_adjust_mode(&self, pat: &'tcx Pat<'tcx>, opt_path_res: Option<Res>) -> AdjustMode {
 280         // When we perform destructuring assignment, we disable default match bindings, which are
 281         // unintuitive in this context.
 282         if !pat.default_binding_modes {
 283             return AdjustMode::Reset;
 284         }
 285         match &pat.kind {
 286             // Type checking these product-like types successfully always require
 287             // that the expected type be of those types and not reference types.
 288             PatKind::Struct(..)
 289             | PatKind::TupleStruct(..)
 290             | PatKind::Tuple(..)
 291             | PatKind::Box(_)
 292             | PatKind::Range(..)
 293             | PatKind::Slice(..) => AdjustMode::Peel,
 294             // String and byte-string literals result in types `&str` and `&[u8]` respectively.
 295             // All other literals result in non-reference types.
 296             // As a result, we allow `if let 0 = &&0 {}` but not `if let "foo" = &&"foo {}`.
 297             //
 298             // Call `resolve_vars_if_possible` here for inline const blocks.
 299             PatKind::Lit(lt) => match self.resolve_vars_if_possible(self.check_expr(lt)).kind() {
 300                 ty::Ref(..) => AdjustMode::Pass,
 301                 _ => AdjustMode::Peel,
 302             },
 303             PatKind::Path(_) => match opt_path_res.unwrap() {
 304                 // These constants can be of a reference type, e.g. `const X: &u8 = &0;`.
 305                 // Peeling the reference types too early will cause type checking failures.
 306                 // Although it would be possible to *also* peel the types of the constants too.
 307                 Res::Def(DefKind::Const | DefKind::AssocConst, _) => AdjustMode::Pass,
 308                 // In the `ValueNS`, we have `SelfCtor(..) | Ctor(_, Const), _)` remaining which
 309                 // could successfully compile. The former being `Self` requires a unit struct.
 310                 // In either case, and unlike constants, the pattern itself cannot be
 311                 // a reference type wherefore peeling doesn't give up any expressiveness.
 312                 _ => AdjustMode::Peel,
 313             },
 314             // When encountering a `& mut? pat` pattern, reset to "by value".
 315             // This is so that `x` and `y` here are by value, as they appear to be:
 316             //
 317             // ```
 318             // match &(&22, &44) {
 319             //   (&x, &y) => ...
 320             // }
 321             // ```
 322             //
 323             // See issue #46688.
 324             PatKind::Ref(..) => AdjustMode::Reset,
 325             // A `_` pattern works with any expected type, so there's no need to do anything.
 326             PatKind::Wild
 327             // Bindings also work with whatever the expected type is,
 328             // and moreover if we peel references off, that will give us the wrong binding type.
 329             // Also, we can have a subpattern `binding @ pat`.
 330             // Each side of the `@` should be treated independently (like with OR-patterns).
 331             | PatKind::Binding(..)
 332             // An OR-pattern just propagates to each individual alternative.
 333             // This is maximally flexible, allowing e.g., `Some(mut x) | &Some(mut x)`.
 334             // In that example, `Some(mut x)` results in `Peel` whereas `&Some(mut x)` in `Reset`.
 335             | PatKind::Or(_) => AdjustMode::Pass,
 336         }
 337     }
 338
 339     /// Peel off as many immediately nested `& mut?` from the expected type as possible
 340     /// and return the new expected type and binding default binding mode.
 341     /// The adjustments vector, if non-empty is stored in a table.
 342     fn peel_off_references(
 343         &self,
 344         pat: &'tcx Pat<'tcx>,
 345         expected: Ty<'tcx>,
 346         mut def_bm: BindingMode,
 347     ) -> (Ty<'tcx>, BindingMode) {
 348         let mut expected = self.resolve_vars_with_obligations(expected);
 349
 350         // Peel off as many `&` or `&mut` from the scrutinee type as possible. For example,
 351         // for `match &&&mut Some(5)` the loop runs three times, aborting when it reaches
 352         // the `Some(5)` which is not of type Ref.
 353         //
 354         // For each ampersand peeled off, update the binding mode and push the original
 355         // type into the adjustments vector.
 356         //
 357         // See the examples in `ui/match-defbm*.rs`.
 358         let mut pat_adjustments = vec![];
 359         while let ty::Ref(_, inner_ty, inner_mutability) = *expected.kind() {
 360             debug!("inspecting {:?}", expected);
 361
 362             debug!("current discriminant is Ref, inserting implicit deref");
 363             // Preserve the reference type. We'll need it later during THIR lowering.
 364             pat_adjustments.push(expected);
 365
 366             expected = inner_ty;
 367             def_bm = ty::BindByReference(match def_bm {
 368                 // If default binding mode is by value, make it `ref` or `ref mut`
 369                 // (depending on whether we observe `&` or `&mut`).
 370                 ty::BindByValue(_) |
 371                 // When `ref mut`, stay a `ref mut` (on `&mut`) or downgrade to `ref` (on `&`).
 372                 ty::BindByReference(hir::Mutability::Mut) => inner_mutability,
 373                 // Once a `ref`, always a `ref`.
 374                 // This is because a `& &mut` cannot mutate the underlying value.
 375                 ty::BindByReference(m @ hir::Mutability::Not) => m,
 376             });
 377         }
 378
 379         if !pat_adjustments.is_empty() {
 380             debug!("default binding mode is now {:?}", def_bm);
 381             self.inh
 382                 .typeck_results
 383                 .borrow_mut()
 384                 .pat_adjustments_mut()
 385                 .insert(pat.hir_id, pat_adjustments);
 386         }
 387
 388         (expected, def_bm)
 389     }
 390
 391     fn check_pat_lit(
 392         &self,
 393         span: Span,
 394         lt: &hir::Expr<'tcx>,
 395         expected: Ty<'tcx>,
 396         ti: TopInfo<'tcx>,
 397     ) -> Ty<'tcx> {
 398         // We've already computed the type above (when checking for a non-ref pat),
 399         // so avoid computing it again.
 400         let ty = self.node_ty(lt.hir_id);
 401
 402         // Byte string patterns behave the same way as array patterns
 403         // They can denote both statically and dynamically-sized byte arrays.
 404         let mut pat_ty = ty;
 405         if let hir::ExprKind::Lit(Spanned { node: ast::LitKind::ByteStr(_), .. }) = lt.kind {
 406             let expected = self.structurally_resolved_type(span, expected);
 407             if let ty::Ref(_, inner_ty, _) = expected.kind() {
 408                 if matches!(inner_ty.kind(), ty::Slice(_)) {
 409                     let tcx = self.tcx;
 410                     trace!(?lt.hir_id.local_id, "polymorphic byte string lit");
 411                     self.typeck_results
 412                         .borrow_mut()
 413                         .treat_byte_string_as_slice
 414                         .insert(lt.hir_id.local_id);
 415                     pat_ty = tcx.mk_imm_ref(tcx.lifetimes.re_static, tcx.mk_slice(tcx.types.u8));
 416                 }
 417             }
 418         }
 419
 420         // Somewhat surprising: in this case, the subtyping relation goes the
 421         // opposite way as the other cases. Actually what we really want is not
 422         // a subtyping relation at all but rather that there exists a LUB
 423         // (so that they can be compared). However, in practice, constants are
 424         // always scalars or strings. For scalars subtyping is irrelevant,
 425         // and for strings `ty` is type is `&'static str`, so if we say that
 426         //
 427         //     &'static str <: expected
 428         //
 429         // then that's equivalent to there existing a LUB.
 430         let cause = self.pattern_cause(ti, span);
 431         if let Some(mut err) = self.demand_suptype_with_origin(&cause, expected, pat_ty) {
 432             err.emit_unless(
 433                 ti.span
 434                     .filter(|&s| {
 435                         // In the case of `if`- and `while`-expressions we've already checked
 436                         // that `scrutinee: bool`. We know that the pattern is `true`,
 437                         // so an error here would be a duplicate and from the wrong POV.
 438                         s.is_desugaring(DesugaringKind::CondTemporary)
 439                     })
 440                     .is_some(),
 441             );
 442         }
 443
 444         pat_ty
 445     }
 446
 447     fn check_pat_range(
 448         &self,
 449         span: Span,
 450         lhs: Option<&'tcx hir::Expr<'tcx>>,
 451         rhs: Option<&'tcx hir::Expr<'tcx>>,
 452         expected: Ty<'tcx>,
 453         ti: TopInfo<'tcx>,
 454     ) -> Ty<'tcx> {
 455         let calc_side = |opt_expr: Option<&'tcx hir::Expr<'tcx>>| match opt_expr {
 456             None => None,
 457             Some(expr) => {
 458                 let ty = self.check_expr(expr);
 459                 // Check that the end-point is possibly of numeric or char type.
 460                 // The early check here is not for correctness, but rather better
 461                 // diagnostics (e.g. when `&str` is being matched, `expected` will
 462                 // be peeled to `str` while ty here is still `&str`, if we don't
 463                 // err early here, a rather confusing unification error will be
 464                 // emitted instead).
 465                 let fail =
 466                     !(ty.is_numeric() || ty.is_char() || ty.is_ty_var() || ty.references_error());
 467                 Some((fail, ty, expr.span))
 468             }
 469         };
 470         let mut lhs = calc_side(lhs);
 471         let mut rhs = calc_side(rhs);
 472
 473         if let (Some((true, ..)), _) | (_, Some((true, ..))) = (lhs, rhs) {
 474             // There exists a side that didn't meet our criteria that the end-point
 475             // be of a numeric or char type, as checked in `calc_side` above.
 476             self.emit_err_pat_range(span, lhs, rhs);
 477             return self.tcx.ty_error();
 478         }
 479
 480         // Unify each side with `expected`.
 481         // Subtyping doesn't matter here, as the value is some kind of scalar.
 482         let demand_eqtype = |x: &mut _, y| {
 483             if let Some((ref mut fail, x_ty, x_span)) = *x {
 484                 if let Some(mut err) = self.demand_eqtype_pat_diag(x_span, expected, x_ty, ti) {
 485                     if let Some((_, y_ty, y_span)) = y {
 486                         self.endpoint_has_type(&mut err, y_span, y_ty);
 487                     }
 488                     err.emit();
 489                     *fail = true;
 490                 };
 491             }
 492         };
 493         demand_eqtype(&mut lhs, rhs);
 494         demand_eqtype(&mut rhs, lhs);
 495
 496         if let (Some((true, ..)), _) | (_, Some((true, ..))) = (lhs, rhs) {
 497             return self.tcx.ty_error();
 498         }
 499
 500         // Find the unified type and check if it's of numeric or char type again.
 501         // This check is needed if both sides are inference variables.
 502         // We require types to be resolved here so that we emit inference failure
 503         // rather than "_ is not a char or numeric".
 504         let ty = self.structurally_resolved_type(span, expected);
 505         if !(ty.is_numeric() || ty.is_char() || ty.references_error()) {
 506             if let Some((ref mut fail, _, _)) = lhs {
 507                 *fail = true;
 508             }
 509             if let Some((ref mut fail, _, _)) = rhs {
 510                 *fail = true;
 511             }
 512             self.emit_err_pat_range(span, lhs, rhs);
 513             return self.tcx.ty_error();
 514         }
 515         ty
 516     }
 517
 518     fn endpoint_has_type(&self, err: &mut Diagnostic, span: Span, ty: Ty<'_>) {
 519         if !ty.references_error() {
 520             err.span_label(span, &format!("this is of type `{}`", ty));
 521         }
 522     }
 523
 524     fn emit_err_pat_range(
 525         &self,
 526         span: Span,
 527         lhs: Option<(bool, Ty<'tcx>, Span)>,
 528         rhs: Option<(bool, Ty<'tcx>, Span)>,
 529     ) {
 530         let span = match (lhs, rhs) {
 531             (Some((true, ..)), Some((true, ..))) => span,
 532             (Some((true, _, sp)), _) => sp,
 533             (_, Some((true, _, sp))) => sp,
 534             _ => span_bug!(span, "emit_err_pat_range: no side failed or exists but still error?"),
 535         };
 536         let mut err = struct_span_err!(
 537             self.tcx.sess,
 538             span,
 539             E0029,
 540             "only `char` and numeric types are allowed in range patterns"
 541         );
 542         let msg = |ty| {
 543             let ty = self.resolve_vars_if_possible(ty);
 544             format!("this is of type `{}` but it should be `char` or numeric", ty)
 545         };
 546         let mut one_side_err = |first_span, first_ty, second: Option<(bool, Ty<'tcx>, Span)>| {
 547             err.span_label(first_span, &msg(first_ty));
 548             if let Some((_, ty, sp)) = second {
 549                 let ty = self.resolve_vars_if_possible(ty);
 550                 self.endpoint_has_type(&mut err, sp, ty);
 551             }
 552         };
 553         match (lhs, rhs) {
 554             (Some((true, lhs_ty, lhs_sp)), Some((true, rhs_ty, rhs_sp))) => {
 555                 err.span_label(lhs_sp, &msg(lhs_ty));
 556                 err.span_label(rhs_sp, &msg(rhs_ty));
 557             }
 558             (Some((true, lhs_ty, lhs_sp)), rhs) => one_side_err(lhs_sp, lhs_ty, rhs),
 559             (lhs, Some((true, rhs_ty, rhs_sp))) => one_side_err(rhs_sp, rhs_ty, lhs),
 560             _ => span_bug!(span, "Impossible, verified above."),
 561         }
 562         if self.tcx.sess.teach(&err.get_code().unwrap()) {
 563             err.note(
 564                 "In a match expression, only numbers and characters can be matched \
 565                     against a range. This is because the compiler checks that the range \
 566                     is non-empty at compile-time, and is unable to evaluate arbitrary \
 567                     comparison functions. If you want to capture values of an orderable \
 568                     type between two end-points, you can use a guard.",
 569             );
 570         }
 571         err.emit();
 572     }
 573
 574     fn check_pat_ident(
 575         &self,
 576         pat: &'tcx Pat<'tcx>,
 577         ba: hir::BindingAnnotation,
 578         var_id: HirId,
 579         sub: Option<&'tcx Pat<'tcx>>,
 580         expected: Ty<'tcx>,
 581         def_bm: BindingMode,
 582         ti: TopInfo<'tcx>,
 583     ) -> Ty<'tcx> {
 584         // Determine the binding mode...
 585         let bm = match ba {
 586             hir::BindingAnnotation::Unannotated => def_bm,
 587             _ => BindingMode::convert(ba),
 588         };
 589         // ...and store it in a side table:
 590         self.inh.typeck_results.borrow_mut().pat_binding_modes_mut().insert(pat.hir_id, bm);
 591
 592         debug!("check_pat_ident: pat.hir_id={:?} bm={:?}", pat.hir_id, bm);
 593
 594         let local_ty = self.local_ty(pat.span, pat.hir_id).decl_ty;
 595         let eq_ty = match bm {
 596             ty::BindByReference(mutbl) => {
 597                 // If the binding is like `ref x | ref mut x`,
 598                 // then `x` is assigned a value of type `&M T` where M is the
 599                 // mutability and T is the expected type.
 600                 //
 601                 // `x` is assigned a value of type `&M T`, hence `&M T <: typeof(x)`
 602                 // is required. However, we use equality, which is stronger.
 603                 // See (note_1) for an explanation.
 604                 self.new_ref_ty(pat.span, mutbl, expected)
 605             }
 606             // Otherwise, the type of x is the expected type `T`.
 607             ty::BindByValue(_) => {
 608                 // As above, `T <: typeof(x)` is required, but we use equality, see (note_1).
 609                 expected
 610             }
 611         };
 612         self.demand_eqtype_pat(pat.span, eq_ty, local_ty, ti);
 613
 614         // If there are multiple arms, make sure they all agree on
 615         // what the type of the binding `x` ought to be.
 616         if var_id != pat.hir_id {
 617             self.check_binding_alt_eq_ty(pat.span, var_id, local_ty, ti);
 618         }
 619
 620         if let Some(p) = sub {
 621             self.check_pat(p, expected, def_bm, TopInfo { parent_pat: Some(pat), ..ti });
 622         }
 623
 624         local_ty
 625     }
 626
 627     fn check_binding_alt_eq_ty(&self, span: Span, var_id: HirId, ty: Ty<'tcx>, ti: TopInfo<'tcx>) {
 628         let var_ty = self.local_ty(span, var_id).decl_ty;
 629         if let Some(mut err) = self.demand_eqtype_pat_diag(span, var_ty, ty, ti) {
 630             let hir = self.tcx.hir();
 631             let var_ty = self.resolve_vars_with_obligations(var_ty);
 632             let msg = format!("first introduced with type `{}` here", var_ty);
 633             err.span_label(hir.span(var_id), msg);
 634             let in_match = hir.parent_iter(var_id).any(|(_, n)| {
 635                 matches!(
 636                     n,
 637                     hir::Node::Expr(hir::Expr {
 638                         kind: hir::ExprKind::Match(.., hir::MatchSource::Normal),
 639                         ..
 640                     })
 641                 )
 642             });
 643             let pre = if in_match { "in the same arm, " } else { "" };
 644             err.note(&format!("{}a binding must have the same type in all alternatives", pre));
 645             err.emit();
 646         }
 647     }
 648
 649     fn borrow_pat_suggestion(
 650         &self,
 651         err: &mut Diagnostic,
 652         pat: &Pat<'_>,
 653         inner: &Pat<'_>,
 654         expected: Ty<'tcx>,
 655     ) {
 656         let tcx = self.tcx;
 657         if let PatKind::Binding(..) = inner.kind {
 658             let binding_parent_id = tcx.hir().get_parent_node(pat.hir_id);
 659             let binding_parent = tcx.hir().get(binding_parent_id);
 660             debug!("inner {:?} pat {:?} parent {:?}", inner, pat, binding_parent);
 661             match binding_parent {
 662                 hir::Node::Param(hir::Param { span, .. })
 663                     if let Ok(snippet) = tcx.sess.source_map().span_to_snippet(inner.span) =>
 664                 {
 665                     err.span_suggestion(
 666                         *span,
 667                         &format!("did you mean `{}`", snippet),
 668                         format!(" &{}", expected),
 669                         Applicability::MachineApplicable,
 670                     );
 671                 }
 672                 hir::Node::Arm(_) | hir::Node::Pat(_) => {
 673                     // rely on match ergonomics or it might be nested `&&pat`
 674                     if let Ok(snippet) = tcx.sess.source_map().span_to_snippet(inner.span) {
 675                         err.span_suggestion(
 676                             pat.span,
 677                             "you can probably remove the explicit borrow",
 678                             snippet,
 679                             Applicability::MaybeIncorrect,
 680                         );
 681                     }
 682                 }
 683                 _ => {} // don't provide suggestions in other cases #55175
 684             }
 685         }
 686     }
 687
 688     pub fn check_dereferenceable(&self, span: Span, expected: Ty<'tcx>, inner: &Pat<'_>) -> bool {
 689         if let PatKind::Binding(..) = inner.kind
 690             && let Some(mt) = self.shallow_resolve(expected).builtin_deref(true)
 691             && let ty::Dynamic(..) = mt.ty.kind()
 692         {
 693                     // This is "x = SomeTrait" being reduced from
 694                     // "let &x = &SomeTrait" or "let box x = Box<SomeTrait>", an error.
 695                     let type_str = self.ty_to_string(expected);
 696                     let mut err = struct_span_err!(
 697                         self.tcx.sess,
 698                         span,
 699                         E0033,
 700                         "type `{}` cannot be dereferenced",
 701                         type_str
 702                     );
 703                     err.span_label(span, format!("type `{}` cannot be dereferenced", type_str));
 704                     if self.tcx.sess.teach(&err.get_code().unwrap()) {
 705                         err.note(CANNOT_IMPLICITLY_DEREF_POINTER_TRAIT_OBJ);
 706                     }
 707                     err.emit();
 708                     return false;
 709                 }
 710         true
 711     }
 712
 713     fn check_pat_struct(
 714         &self,
 715         pat: &'tcx Pat<'tcx>,
 716         qpath: &hir::QPath<'_>,
 717         fields: &'tcx [hir::PatField<'tcx>],
 718         has_rest_pat: bool,
 719         expected: Ty<'tcx>,
 720         def_bm: BindingMode,
 721         ti: TopInfo<'tcx>,
 722     ) -> Ty<'tcx> {
 723         // Resolve the path and check the definition for errors.
 724         let Some((variant, pat_ty)) = self.check_struct_path(qpath, pat.hir_id) else {
 725             let err = self.tcx.ty_error();
 726             for field in fields {
 727                 let ti = TopInfo { parent_pat: Some(pat), ..ti };
 728                 self.check_pat(field.pat, err, def_bm, ti);
 729             }
 730             return err;
 731         };
 732
 733         // Type-check the path.
 734         self.demand_eqtype_pat(pat.span, expected, pat_ty, ti);
 735
 736         // Type-check subpatterns.
 737         if self.check_struct_pat_fields(pat_ty, &pat, variant, fields, has_rest_pat, def_bm, ti) {
 738             pat_ty
 739         } else {
 740             self.tcx.ty_error()
 741         }
 742     }
 743
 744     fn check_pat_path<'b>(
 745         &self,
 746         pat: &Pat<'_>,
 747         path_resolution: (Res, Option<Ty<'tcx>>, &'b [hir::PathSegment<'b>]),
 748         expected: Ty<'tcx>,
 749         ti: TopInfo<'tcx>,
 750     ) -> Ty<'tcx> {
 751         let tcx = self.tcx;
 752
 753         // We have already resolved the path.
 754         let (res, opt_ty, segments) = path_resolution;
 755         match res {
 756             Res::Err => {
 757                 self.set_tainted_by_errors();
 758                 return tcx.ty_error();
 759             }
 760             Res::Def(DefKind::AssocFn | DefKind::Ctor(_, CtorKind::Fictive | CtorKind::Fn), _) => {
 761                 report_unexpected_variant_res(tcx, res, pat.span);
 762                 return tcx.ty_error();
 763             }
 764             Res::SelfCtor(..)
 765             | Res::Def(
 766                 DefKind::Ctor(_, CtorKind::Const)
 767                 | DefKind::Const
 768                 | DefKind::AssocConst
 769                 | DefKind::ConstParam,
 770                 _,
 771             ) => {} // OK
 772             _ => bug!("unexpected pattern resolution: {:?}", res),
 773         }
 774
 775         // Type-check the path.
 776         let (pat_ty, pat_res) =
 777             self.instantiate_value_path(segments, opt_ty, res, pat.span, pat.hir_id);
 778         if let Some(err) =
 779             self.demand_suptype_with_origin(&self.pattern_cause(ti, pat.span), expected, pat_ty)
 780         {
 781             self.emit_bad_pat_path(err, pat.span, res, pat_res, pat_ty, segments, ti.parent_pat);
 782         }
 783         pat_ty
 784     }
 785
 786     fn maybe_suggest_range_literal(
 787         &self,
 788         e: &mut Diagnostic,
 789         opt_def_id: Option<hir::def_id::DefId>,
 790         ident: Ident,
 791     ) -> bool {
 792         match opt_def_id {
 793             Some(def_id) => match self.tcx.hir().get_if_local(def_id) {
 794                 Some(hir::Node::Item(hir::Item {
 795                     kind: hir::ItemKind::Const(_, body_id), ..
 796                 })) => match self.tcx.hir().get(body_id.hir_id) {
 797                     hir::Node::Expr(expr) => {
 798                         if hir::is_range_literal(expr) {
 799                             let span = self.tcx.hir().span(body_id.hir_id);
 800                             if let Ok(snip) = self.tcx.sess.source_map().span_to_snippet(span) {
 801                                 e.span_suggestion_verbose(
 802                                     ident.span,
 803                                     "you may want to move the range into the match block",
 804                                     snip,
 805                                     Applicability::MachineApplicable,
 806                                 );
 807                                 return true;
 808                             }
 809                         }
 810                     }
 811                     _ => (),
 812                 },
 813                 _ => (),
 814             },
 815             _ => (),
 816         }
 817         false
 818     }
 819
 820     fn emit_bad_pat_path<'b>(
 821         &self,
 822         mut e: DiagnosticBuilder<'_, ErrorGuaranteed>,
 823         pat_span: Span,
 824         res: Res,
 825         pat_res: Res,
 826         pat_ty: Ty<'tcx>,
 827         segments: &'b [hir::PathSegment<'b>],
 828         parent_pat: Option<&Pat<'_>>,
 829     ) {
 830         if let Some(span) = self.tcx.hir().res_span(pat_res) {
 831             e.span_label(span, &format!("{} defined here", res.descr()));
 832             if let [hir::PathSegment { ident, .. }] = &*segments {
 833                 e.span_label(
 834                     pat_span,
 835                     &format!(
 836                         "`{}` is interpreted as {} {}, not a new binding",
 837                         ident,
 838                         res.article(),
 839                         res.descr(),
 840                     ),
 841                 );
 842                 match parent_pat {
 843                     Some(Pat { kind: hir::PatKind::Struct(..), .. }) => {
 844                         e.span_suggestion_verbose(
 845                             ident.span.shrink_to_hi(),
 846                             "bind the struct field to a different name instead",
 847                             format!(": other_{}", ident.as_str().to_lowercase()),
 848                             Applicability::HasPlaceholders,
 849                         );
 850                     }
 851                     _ => {
 852                         let (type_def_id, item_def_id) = match pat_ty.kind() {
 853                             Adt(def, _) => match res {
 854                                 Res::Def(DefKind::Const, def_id) => (Some(def.did()), Some(def_id)),
 855                                 _ => (None, None),
 856                             },
 857                             _ => (None, None),
 858                         };
 859
 860                         let ranges = &[
 861                             self.tcx.lang_items().range_struct(),
 862                             self.tcx.lang_items().range_from_struct(),
 863                             self.tcx.lang_items().range_to_struct(),
 864                             self.tcx.lang_items().range_full_struct(),
 865                             self.tcx.lang_items().range_inclusive_struct(),
 866                             self.tcx.lang_items().range_to_inclusive_struct(),
 867                         ];
 868                         if type_def_id != None && ranges.contains(&type_def_id) {
 869                             if !self.maybe_suggest_range_literal(&mut e, item_def_id, *ident) {
 870                                 let msg = "constants only support matching by type, \
 871                                     if you meant to match against a range of values, \
 872                                     consider using a range pattern like `min ..= max` in the match block";
 873                                 e.note(msg);
 874                             }
 875                         } else {
 876                             let msg = "introduce a new binding instead";
 877                             let sugg = format!("other_{}", ident.as_str().to_lowercase());
 878                             e.span_suggestion(
 879                                 ident.span,
 880                                 msg,
 881                                 sugg,
 882                                 Applicability::HasPlaceholders,
 883                             );
 884                         }
 885                     }
 886                 };
 887             }
 888         }
 889         e.emit();
 890     }
 891
 892     fn check_pat_tuple_struct(
 893         &self,
 894         pat: &'tcx Pat<'tcx>,
 895         qpath: &'tcx hir::QPath<'tcx>,
 896         subpats: &'tcx [Pat<'tcx>],
 897         ddpos: Option<usize>,
 898         expected: Ty<'tcx>,
 899         def_bm: BindingMode,
 900         ti: TopInfo<'tcx>,
 901     ) -> Ty<'tcx> {
 902         let tcx = self.tcx;
 903         let on_error = || {
 904             let parent_pat = Some(pat);
 905             for pat in subpats {
 906                 self.check_pat(pat, tcx.ty_error(), def_bm, TopInfo { parent_pat, ..ti });
 907             }
 908         };
 909         let report_unexpected_res = |res: Res| {
 910             let sm = tcx.sess.source_map();
 911             let path_str = sm
 912                 .span_to_snippet(sm.span_until_char(pat.span, '('))
 913                 .map_or_else(|_| String::new(), |s| format!(" `{}`", s.trim_end()));
 914             let msg = format!(
 915                 "expected tuple struct or tuple variant, found {}{}",
 916                 res.descr(),
 917                 path_str
 918             );
 919
 920             let mut err = struct_span_err!(tcx.sess, pat.span, E0164, "{}", msg);
 921             match res {
 922                 Res::Def(DefKind::Fn | DefKind::AssocFn, _) => {
 923                     err.span_label(pat.span, "`fn` calls are not allowed in patterns");
 924                     err.help(
 925                         "for more information, visit \
 926                               https://doc.rust-lang.org/book/ch18-00-patterns.html",
 927                     );
 928                 }
 929                 _ => {
 930                     err.span_label(pat.span, "not a tuple variant or struct");
 931                 }
 932             }
 933             err.emit();
 934             on_error();
 935         };
 936
 937         // Resolve the path and check the definition for errors.
 938         let (res, opt_ty, segments) =
 939             self.resolve_ty_and_res_fully_qualified_call(qpath, pat.hir_id, pat.span);
 940         if res == Res::Err {
 941             self.set_tainted_by_errors();
 942             on_error();
 943             return self.tcx.ty_error();
 944         }
 945
 946         // Type-check the path.
 947         let (pat_ty, res) =
 948             self.instantiate_value_path(segments, opt_ty, res, pat.span, pat.hir_id);
 949         if !pat_ty.is_fn() {
 950             report_unexpected_res(res);
 951             return tcx.ty_error();
 952         }
 953
 954         let variant = match res {
 955             Res::Err => {
 956                 self.set_tainted_by_errors();
 957                 on_error();
 958                 return tcx.ty_error();
 959             }
 960             Res::Def(DefKind::AssocConst | DefKind::AssocFn, _) => {
 961                 report_unexpected_res(res);
 962                 return tcx.ty_error();
 963             }
 964             Res::Def(DefKind::Ctor(_, CtorKind::Fn), _) => tcx.expect_variant_res(res),
 965             _ => bug!("unexpected pattern resolution: {:?}", res),
 966         };
 967
 968         // Replace constructor type with constructed type for tuple struct patterns.
 969         let pat_ty = pat_ty.fn_sig(tcx).output();
 970         let pat_ty = pat_ty.no_bound_vars().expect("expected fn type");
 971
 972         // Type-check the tuple struct pattern against the expected type.
 973         let diag = self.demand_eqtype_pat_diag(pat.span, expected, pat_ty, ti);
 974         let had_err = if let Some(mut err) = diag {
 975             err.emit();
 976             true
 977         } else {
 978             false
 979         };
 980
 981         // Type-check subpatterns.
 982         if subpats.len() == variant.fields.len()
 983             || subpats.len() < variant.fields.len() && ddpos.is_some()
 984         {
 985             let ty::Adt(_, substs) = pat_ty.kind() else {
 986                 bug!("unexpected pattern type {:?}", pat_ty);
 987             };
 988             for (i, subpat) in subpats.iter().enumerate_and_adjust(variant.fields.len(), ddpos) {
 989                 let field_ty = self.field_ty(subpat.span, &variant.fields[i], substs);
 990                 self.check_pat(subpat, field_ty, def_bm, TopInfo { parent_pat: Some(pat), ..ti });
 991
 992                 self.tcx.check_stability(
 993                     variant.fields[i].did,
 994                     Some(pat.hir_id),
 995                     subpat.span,
 996                     None,
 997                 );
 998             }
 999         } else {
1000             // Pattern has wrong number of fields.
1001             self.e0023(pat.span, res, qpath, subpats, &variant.fields, expected, had_err);
1002             on_error();
1003             return tcx.ty_error();
1004         }
1005         pat_ty
1006     }
1007
1008     fn e0023(
1009         &self,
1010         pat_span: Span,
1011         res: Res,
1012         qpath: &hir::QPath<'_>,
1013         subpats: &'tcx [Pat<'tcx>],
1014         fields: &'tcx [ty::FieldDef],
1015         expected: Ty<'tcx>,
1016         had_err: bool,
1017     ) {
1018         let subpats_ending = pluralize!(subpats.len());
1019         let fields_ending = pluralize!(fields.len());
1020
1021         let subpat_spans = if subpats.is_empty() {
1022             vec![pat_span]
1023         } else {
1024             subpats.iter().map(|p| p.span).collect()
1025         };
1026         let last_subpat_span = *subpat_spans.last().unwrap();
1027         let res_span = self.tcx.def_span(res.def_id());
1028         let def_ident_span = self.tcx.def_ident_span(res.def_id()).unwrap_or(res_span);
1029         let field_def_spans = if fields.is_empty() {
1030             vec![res_span]
1031         } else {
1032             fields.iter().map(|f| f.ident(self.tcx).span).collect()
1033         };
1034         let last_field_def_span = *field_def_spans.last().unwrap();
1035
1036         let mut err = struct_span_err!(
1037             self.tcx.sess,
1038             MultiSpan::from_spans(subpat_spans),
1039             E0023,
1040             "this pattern has {} field{}, but the corresponding {} has {} field{}",
1041             subpats.len(),
1042             subpats_ending,
1043             res.descr(),
1044             fields.len(),
1045             fields_ending,
1046         );
1047         err.span_label(
1048             last_subpat_span,
1049             &format!("expected {} field{}, found {}", fields.len(), fields_ending, subpats.len()),
1050         );
1051         if self.tcx.sess.source_map().is_multiline(qpath.span().between(last_subpat_span)) {
1052             err.span_label(qpath.span(), "");
1053         }
1054         if self.tcx.sess.source_map().is_multiline(def_ident_span.between(last_field_def_span)) {
1055             err.span_label(def_ident_span, format!("{} defined here", res.descr()));
1056         }
1057         for span in &field_def_spans[..field_def_spans.len() - 1] {
1058             err.span_label(*span, "");
1059         }
1060         err.span_label(
1061             last_field_def_span,
1062             &format!("{} has {} field{}", res.descr(), fields.len(), fields_ending),
1063         );
1064
1065         // Identify the case `Some(x, y)` where the expected type is e.g. `Option<(T, U)>`.
1066         // More generally, the expected type wants a tuple variant with one field of an
1067         // N-arity-tuple, e.g., `V_i((p_0, .., p_N))`. Meanwhile, the user supplied a pattern
1068         // with the subpatterns directly in the tuple variant pattern, e.g., `V_i(p_0, .., p_N)`.
1069         let missing_parentheses = match (&expected.kind(), fields, had_err) {
1070             // #67037: only do this if we could successfully type-check the expected type against
1071             // the tuple struct pattern. Otherwise the substs could get out of range on e.g.,
1072             // `let P() = U;` where `P != U` with `struct P<T>(T);`.
1073             (ty::Adt(_, substs), [field], false) => {
1074                 let field_ty = self.field_ty(pat_span, field, substs);
1075                 match field_ty.kind() {
1076                     ty::Tuple(fields) => fields.len() == subpats.len(),
1077                     _ => false,
1078                 }
1079             }
1080             _ => false,
1081         };
1082         if missing_parentheses {
1083             let (left, right) = match subpats {
1084                 // This is the zero case; we aim to get the "hi" part of the `QPath`'s
1085                 // span as the "lo" and then the "hi" part of the pattern's span as the "hi".
1086                 // This looks like:
1087                 //
1088                 // help: missing parentheses
1089                 //   |
1090                 // L |     let A(()) = A(());
1091                 //   |          ^  ^
1092                 [] => (qpath.span().shrink_to_hi(), pat_span),
1093                 // Easy case. Just take the "lo" of the first sub-pattern and the "hi" of the
1094                 // last sub-pattern. In the case of `A(x)` the first and last may coincide.
1095                 // This looks like:
1096                 //
1097                 // help: missing parentheses
1098                 //   |
1099                 // L |     let A((x, y)) = A((1, 2));
1100                 //   |           ^    ^
1101                 [first, ..] => (first.span.shrink_to_lo(), subpats.last().unwrap().span),
1102             };
1103             err.multipart_suggestion(
1104                 "missing parentheses",
1105                 vec![(left, "(".to_string()), (right.shrink_to_hi(), ")".to_string())],
1106                 Applicability::MachineApplicable,
1107             );
1108         } else if fields.len() > subpats.len() && pat_span != DUMMY_SP {
1109             let after_fields_span = pat_span.with_hi(pat_span.hi() - BytePos(1)).shrink_to_hi();
1110             let all_fields_span = match subpats {
1111                 [] => after_fields_span,
1112                 [field] => field.span,
1113                 [first, .., last] => first.span.to(last.span),
1114             };
1115
1116             // Check if all the fields in the pattern are wildcards.
1117             let all_wildcards = subpats.iter().all(|pat| matches!(pat.kind, PatKind::Wild));
1118             let first_tail_wildcard =
1119                 subpats.iter().enumerate().fold(None, |acc, (pos, pat)| match (acc, &pat.kind) {
1120                     (None, PatKind::Wild) => Some(pos),
1121                     (Some(_), PatKind::Wild) => acc,
1122                     _ => None,
1123                 });
1124             let tail_span = match first_tail_wildcard {
1125                 None => after_fields_span,
1126                 Some(0) => subpats[0].span.to(after_fields_span),
1127                 Some(pos) => subpats[pos - 1].span.shrink_to_hi().to(after_fields_span),
1128             };
1129
1130             // FIXME: heuristic-based suggestion to check current types for where to add `_`.
1131             let mut wildcard_sugg = vec!["_"; fields.len() - subpats.len()].join(", ");
1132             if !subpats.is_empty() {
1133                 wildcard_sugg = String::from(", ") + &wildcard_sugg;
1134             }
1135
1136             err.span_suggestion_verbose(
1137                 after_fields_span,
1138                 "use `_` to explicitly ignore each field",
1139                 wildcard_sugg,
1140                 Applicability::MaybeIncorrect,
1141             );
1142
1143             // Only suggest `..` if more than one field is missing
1144             // or the pattern consists of all wildcards.
1145             if fields.len() - subpats.len() > 1 || all_wildcards {
1146                 if subpats.is_empty() || all_wildcards {
1147                     err.span_suggestion_verbose(
1148                         all_fields_span,
1149                         "use `..` to ignore all fields",
1150                         String::from(".."),
1151                         Applicability::MaybeIncorrect,
1152                     );
1153                 } else {
1154                     err.span_suggestion_verbose(
1155                         tail_span,
1156                         "use `..` to ignore the rest of the fields",
1157                         String::from(", .."),
1158                         Applicability::MaybeIncorrect,
1159                     );
1160                 }
1161             }
1162         }
1163
1164         err.emit();
1165     }
1166
1167     fn check_pat_tuple(
1168         &self,
1169         span: Span,
1170         elements: &'tcx [Pat<'tcx>],
1171         ddpos: Option<usize>,
1172         expected: Ty<'tcx>,
1173         def_bm: BindingMode,
1174         ti: TopInfo<'tcx>,
1175     ) -> Ty<'tcx> {
1176         let tcx = self.tcx;
1177         let mut expected_len = elements.len();
1178         if ddpos.is_some() {
1179             // Require known type only when `..` is present.
1180             if let ty::Tuple(tys) = self.structurally_resolved_type(span, expected).kind() {
1181                 expected_len = tys.len();
1182             }
1183         }
1184         let max_len = cmp::max(expected_len, elements.len());
1185
1186         let element_tys_iter = (0..max_len).map(|_| {
1187             self.next_ty_var(
1188                 // FIXME: `MiscVariable` for now -- obtaining the span and name information
1189                 // from all tuple elements isn't trivial.
1190                 TypeVariableOrigin { kind: TypeVariableOriginKind::TypeInference, span },
1191             )
1192         });
1193         let element_tys = tcx.mk_type_list(element_tys_iter);
1194         let pat_ty = tcx.mk_ty(ty::Tuple(element_tys));
1195         if let Some(mut err) = self.demand_eqtype_pat_diag(span, expected, pat_ty, ti) {
1196             err.emit();
1197             // Walk subpatterns with an expected type of `err` in this case to silence
1198             // further errors being emitted when using the bindings. #50333
1199             let element_tys_iter = (0..max_len).map(|_| tcx.ty_error());
1200             for (_, elem) in elements.iter().enumerate_and_adjust(max_len, ddpos) {
1201                 self.check_pat(elem, tcx.ty_error(), def_bm, ti);
1202             }
1203             tcx.mk_tup(element_tys_iter)
1204         } else {
1205             for (i, elem) in elements.iter().enumerate_and_adjust(max_len, ddpos) {
1206                 self.check_pat(elem, element_tys[i], def_bm, ti);
1207             }
1208             pat_ty
1209         }
1210     }
1211
1212     fn check_struct_pat_fields(
1213         &self,
1214         adt_ty: Ty<'tcx>,
1215         pat: &'tcx Pat<'tcx>,
1216         variant: &'tcx ty::VariantDef,
1217         fields: &'tcx [hir::PatField<'tcx>],
1218         has_rest_pat: bool,
1219         def_bm: BindingMode,
1220         ti: TopInfo<'tcx>,
1221     ) -> bool {
1222         let tcx = self.tcx;
1223
1224         let ty::Adt(adt, substs) = adt_ty.kind() else {
1225             span_bug!(pat.span, "struct pattern is not an ADT");
1226         };
1227
1228         // Index the struct fields' types.
1229         let field_map = variant
1230             .fields
1231             .iter()
1232             .enumerate()
1233             .map(|(i, field)| (field.ident(self.tcx).normalize_to_macros_2_0(), (i, field)))
1234             .collect::<FxHashMap<_, _>>();
1235
1236         // Keep track of which fields have already appeared in the pattern.
1237         let mut used_fields = FxHashMap::default();
1238         let mut no_field_errors = true;
1239
1240         let mut inexistent_fields = vec![];
1241         // Typecheck each field.
1242         for field in fields {
1243             let span = field.span;
1244             let ident = tcx.adjust_ident(field.ident, variant.def_id);
1245             let field_ty = match used_fields.entry(ident) {
1246                 Occupied(occupied) => {
1247                     self.error_field_already_bound(span, field.ident, *occupied.get());
1248                     no_field_errors = false;
1249                     tcx.ty_error()
1250                 }
1251                 Vacant(vacant) => {
1252                     vacant.insert(span);
1253                     field_map
1254                         .get(&ident)
1255                         .map(|(i, f)| {
1256                             self.write_field_index(field.hir_id, *i);
1257                             self.tcx.check_stability(f.did, Some(pat.hir_id), span, None);
1258                             self.field_ty(span, f, substs)
1259                         })
1260                         .unwrap_or_else(|| {
1261                             inexistent_fields.push(field);
1262                             no_field_errors = false;
1263                             tcx.ty_error()
1264                         })
1265                 }
1266             };
1267
1268             self.check_pat(field.pat, field_ty, def_bm, TopInfo { parent_pat: Some(pat), ..ti });
1269         }
1270
1271         let mut unmentioned_fields = variant
1272             .fields
1273             .iter()
1274             .map(|field| (field, field.ident(self.tcx).normalize_to_macros_2_0()))
1275             .filter(|(_, ident)| !used_fields.contains_key(ident))
1276             .collect::<Vec<_>>();
1277
1278         let inexistent_fields_err = if !(inexistent_fields.is_empty() || variant.is_recovered())
1279             && !inexistent_fields.iter().any(|field| field.ident.name == kw::Underscore)
1280         {
1281             Some(self.error_inexistent_fields(
1282                 adt.variant_descr(),
1283                 &inexistent_fields,
1284                 &mut unmentioned_fields,
1285                 variant,
1286                 substs,
1287             ))
1288         } else {
1289             None
1290         };
1291
1292         // Require `..` if struct has non_exhaustive attribute.
1293         let non_exhaustive = variant.is_field_list_non_exhaustive() && !adt.did().is_local();
1294         if non_exhaustive && !has_rest_pat {
1295             self.error_foreign_non_exhaustive_spat(pat, adt.variant_descr(), fields.is_empty());
1296         }
1297
1298         let mut unmentioned_err = None;
1299         // Report an error if an incorrect number of fields was specified.
1300         if adt.is_union() {
1301             if fields.len() != 1 {
1302                 tcx.sess
1303                     .struct_span_err(pat.span, "union patterns should have exactly one field")
1304                     .emit();
1305             }
1306             if has_rest_pat {
1307                 tcx.sess.struct_span_err(pat.span, "`..` cannot be used in union patterns").emit();
1308             }
1309         } else if !unmentioned_fields.is_empty() {
1310             let accessible_unmentioned_fields: Vec<_> = unmentioned_fields
1311                 .iter()
1312                 .copied()
1313                 .filter(|(field, _)| {
1314                     field.vis.is_accessible_from(tcx.parent_module(pat.hir_id).to_def_id(), tcx)
1315                         && !matches!(
1316                             tcx.eval_stability(field.did, None, DUMMY_SP, None),
1317                             EvalResult::Deny { .. }
1318                         )
1319                         // We only want to report the error if it is hidden and not local
1320                         && !(tcx.is_doc_hidden(field.did) && !field.did.is_local())
1321                 })
1322                 .collect();
1323
1324             if !has_rest_pat {
1325                 if accessible_unmentioned_fields.is_empty() {
1326                     unmentioned_err = Some(self.error_no_accessible_fields(pat, fields));
1327                 } else {
1328                     unmentioned_err = Some(self.error_unmentioned_fields(
1329                         pat,
1330                         &accessible_unmentioned_fields,
1331                         accessible_unmentioned_fields.len() != unmentioned_fields.len(),
1332                         fields,
1333                     ));
1334                 }
1335             } else if non_exhaustive && !accessible_unmentioned_fields.is_empty() {
1336                 self.lint_non_exhaustive_omitted_patterns(
1337                     pat,
1338                     &accessible_unmentioned_fields,
1339                     adt_ty,
1340                 )
1341             }
1342         }
1343         match (inexistent_fields_err, unmentioned_err) {
1344             (Some(mut i), Some(mut u)) => {
1345                 if let Some(mut e) = self.error_tuple_variant_as_struct_pat(pat, fields, variant) {
1346                     // We don't want to show the nonexistent fields error when this was
1347                     // `Foo { a, b }` when it should have been `Foo(a, b)`.
1348                     i.delay_as_bug();
1349                     u.delay_as_bug();
1350                     e.emit();
1351                 } else {
1352                     i.emit();
1353                     u.emit();
1354                 }
1355             }
1356             (None, Some(mut u)) => {
1357                 if let Some(mut e) = self.error_tuple_variant_as_struct_pat(pat, fields, variant) {
1358                     u.delay_as_bug();
1359                     e.emit();
1360                 } else {
1361                     u.emit();
1362                 }
1363             }
1364             (Some(mut err), None) => {
1365                 err.emit();
1366             }
1367             (None, None) if let Some(mut err) =
1368                     self.error_tuple_variant_index_shorthand(variant, pat, fields) =>
1369             {
1370                 err.emit();
1371             }
1372             (None, None) => {}
1373         }
1374         no_field_errors
1375     }
1376
1377     fn error_tuple_variant_index_shorthand(
1378         &self,
1379         variant: &VariantDef,
1380         pat: &'_ Pat<'_>,
1381         fields: &[hir::PatField<'_>],
1382     ) -> Option<DiagnosticBuilder<'_, ErrorGuaranteed>> {
1383         // if this is a tuple struct, then all field names will be numbers
1384         // so if any fields in a struct pattern use shorthand syntax, they will
1385         // be invalid identifiers (for example, Foo { 0, 1 }).
1386         if let (CtorKind::Fn, PatKind::Struct(qpath, field_patterns, ..)) =
1387             (variant.ctor_kind, &pat.kind)
1388         {
1389             let has_shorthand_field_name = field_patterns.iter().any(|field| field.is_shorthand);
1390             if has_shorthand_field_name {
1391                 let path = rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| {
1392                     s.print_qpath(qpath, false)
1393                 });
1394                 let mut err = struct_span_err!(
1395                     self.tcx.sess,
1396                     pat.span,
1397                     E0769,
1398                     "tuple variant `{}` written as struct variant",
1399                     path
1400                 );
1401                 err.span_suggestion_verbose(
1402                     qpath.span().shrink_to_hi().to(pat.span.shrink_to_hi()),
1403                     "use the tuple variant pattern syntax instead",
1404                     format!("({})", self.get_suggested_tuple_struct_pattern(fields, variant)),
1405                     Applicability::MaybeIncorrect,
1406                 );
1407                 return Some(err);
1408             }
1409         }
1410         None
1411     }
1412
1413     fn error_foreign_non_exhaustive_spat(&self, pat: &Pat<'_>, descr: &str, no_fields: bool) {
1414         let sess = self.tcx.sess;
1415         let sm = sess.source_map();
1416         let sp_brace = sm.end_point(pat.span);
1417         let sp_comma = sm.end_point(pat.span.with_hi(sp_brace.hi()));
1418         let sugg = if no_fields || sp_brace != sp_comma { ".. }" } else { ", .. }" };
1419
1420         let mut err = struct_span_err!(
1421             sess,
1422             pat.span,
1423             E0638,
1424             "`..` required with {} marked as non-exhaustive",
1425             descr
1426         );
1427         err.span_suggestion_verbose(
1428             sp_comma,
1429             "add `..` at the end of the field list to ignore all other fields",
1430             sugg.to_string(),
1431             Applicability::MachineApplicable,
1432         );
1433         err.emit();
1434     }
1435
1436     fn error_field_already_bound(&self, span: Span, ident: Ident, other_field: Span) {
1437         struct_span_err!(
1438             self.tcx.sess,
1439             span,
1440             E0025,
1441             "field `{}` bound multiple times in the pattern",
1442             ident
1443         )
1444         .span_label(span, format!("multiple uses of `{}` in pattern", ident))
1445         .span_label(other_field, format!("first use of `{}`", ident))
1446         .emit();
1447     }
1448
1449     fn error_inexistent_fields(
1450         &self,
1451         kind_name: &str,
1452         inexistent_fields: &[&hir::PatField<'tcx>],
1453         unmentioned_fields: &mut Vec<(&'tcx ty::FieldDef, Ident)>,
1454         variant: &ty::VariantDef,
1455         substs: &'tcx ty::List<ty::subst::GenericArg<'tcx>>,
1456     ) -> DiagnosticBuilder<'tcx, ErrorGuaranteed> {
1457         let tcx = self.tcx;
1458         let (field_names, t, plural) = if inexistent_fields.len() == 1 {
1459             (format!("a field named `{}`", inexistent_fields[0].ident), "this", "")
1460         } else {
1461             (
1462                 format!(
1463                     "fields named {}",
1464                     inexistent_fields
1465                         .iter()
1466                         .map(|field| format!("`{}`", field.ident))
1467                         .collect::<Vec<String>>()
1468                         .join(", ")
1469                 ),
1470                 "these",
1471                 "s",
1472             )
1473         };
1474         let spans = inexistent_fields.iter().map(|field| field.ident.span).collect::<Vec<_>>();
1475         let mut err = struct_span_err!(
1476             tcx.sess,
1477             spans,
1478             E0026,
1479             "{} `{}` does not have {}",
1480             kind_name,
1481             tcx.def_path_str(variant.def_id),
1482             field_names
1483         );
1484         if let Some(pat_field) = inexistent_fields.last() {
1485             err.span_label(
1486                 pat_field.ident.span,
1487                 format!(
1488                     "{} `{}` does not have {} field{}",
1489                     kind_name,
1490                     tcx.def_path_str(variant.def_id),
1491                     t,
1492                     plural
1493                 ),
1494             );
1495
1496             if unmentioned_fields.len() == 1 {
1497                 let input =
1498                     unmentioned_fields.iter().map(|(_, field)| field.name).collect::<Vec<_>>();
1499                 let suggested_name = find_best_match_for_name(&input, pat_field.ident.name, None);
1500                 if let Some(suggested_name) = suggested_name {
1501                     err.span_suggestion(
1502                         pat_field.ident.span,
1503                         "a field with a similar name exists",
1504                         suggested_name.to_string(),
1505                         Applicability::MaybeIncorrect,
1506                     );
1507
1508                     // When we have a tuple struct used with struct we don't want to suggest using
1509                     // the (valid) struct syntax with numeric field names. Instead we want to
1510                     // suggest the expected syntax. We infer that this is the case by parsing the
1511                     // `Ident` into an unsized integer. The suggestion will be emitted elsewhere in
1512                     // `smart_resolve_context_dependent_help`.
1513                     if suggested_name.to_ident_string().parse::<usize>().is_err() {
1514                         // We don't want to throw `E0027` in case we have thrown `E0026` for them.
1515                         unmentioned_fields.retain(|&(_, x)| x.name != suggested_name);
1516                     }
1517                 } else if inexistent_fields.len() == 1 {
1518                     match pat_field.pat.kind {
1519                         PatKind::Lit(expr)
1520                             if !self.can_coerce(
1521                                 self.typeck_results.borrow().expr_ty(expr),
1522                                 self.field_ty(
1523                                     unmentioned_fields[0].1.span,
1524                                     unmentioned_fields[0].0,
1525                                     substs,
1526                                 ),
1527                             ) => {}
1528                         _ => {
1529                             let unmentioned_field = unmentioned_fields[0].1.name;
1530                             err.span_suggestion_short(
1531                                 pat_field.ident.span,
1532                                 &format!(
1533                                     "`{}` has a field named `{}`",
1534                                     tcx.def_path_str(variant.def_id),
1535                                     unmentioned_field
1536                                 ),
1537                                 unmentioned_field.to_string(),
1538                                 Applicability::MaybeIncorrect,
1539                             );
1540                         }
1541                     }
1542                 }
1543             }
1544         }
1545         if tcx.sess.teach(&err.get_code().unwrap()) {
1546             err.note(
1547                 "This error indicates that a struct pattern attempted to \
1548                  extract a non-existent field from a struct. Struct fields \
1549                  are identified by the name used before the colon : so struct \
1550                  patterns should resemble the declaration of the struct type \
1551                  being matched.\n\n\
1552                  If you are using shorthand field patterns but want to refer \
1553                  to the struct field by a different name, you should rename \
1554                  it explicitly.",
1555             );
1556         }
1557         err
1558     }
1559
1560     fn error_tuple_variant_as_struct_pat(
1561         &self,
1562         pat: &Pat<'_>,
1563         fields: &'tcx [hir::PatField<'tcx>],
1564         variant: &ty::VariantDef,
1565     ) -> Option<DiagnosticBuilder<'tcx, ErrorGuaranteed>> {
1566         if let (CtorKind::Fn, PatKind::Struct(qpath, ..)) = (variant.ctor_kind, &pat.kind) {
1567             let path = rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| {
1568                 s.print_qpath(qpath, false)
1569             });
1570             let mut err = struct_span_err!(
1571                 self.tcx.sess,
1572                 pat.span,
1573                 E0769,
1574                 "tuple variant `{}` written as struct variant",
1575                 path
1576             );
1577             let (sugg, appl) = if fields.len() == variant.fields.len() {
1578                 (
1579                     self.get_suggested_tuple_struct_pattern(fields, variant),
1580                     Applicability::MachineApplicable,
1581                 )
1582             } else {
1583                 (
1584                     variant.fields.iter().map(|_| "_").collect::<Vec<&str>>().join(", "),
1585                     Applicability::MaybeIncorrect,
1586                 )
1587             };
1588             err.span_suggestion_verbose(
1589                 qpath.span().shrink_to_hi().to(pat.span.shrink_to_hi()),
1590                 "use the tuple variant pattern syntax instead",
1591                 format!("({})", sugg),
1592                 appl,
1593             );
1594             return Some(err);
1595         }
1596         None
1597     }
1598
1599     fn get_suggested_tuple_struct_pattern(
1600         &self,
1601         fields: &[hir::PatField<'_>],
1602         variant: &VariantDef,
1603     ) -> String {
1604         let variant_field_idents =
1605             variant.fields.iter().map(|f| f.ident(self.tcx)).collect::<Vec<Ident>>();
1606         fields
1607             .iter()
1608             .map(|field| {
1609                 match self.tcx.sess.source_map().span_to_snippet(field.pat.span) {
1610                     Ok(f) => {
1611                         // Field names are numbers, but numbers
1612                         // are not valid identifiers
1613                         if variant_field_idents.contains(&field.ident) {
1614                             String::from("_")
1615                         } else {
1616                             f
1617                         }
1618                     }
1619                     Err(_) => rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| {
1620                         s.print_pat(field.pat)
1621                     }),
1622                 }
1623             })
1624             .collect::<Vec<String>>()
1625             .join(", ")
1626     }
1627
1628     /// Returns a diagnostic reporting a struct pattern which is missing an `..` due to
1629     /// inaccessible fields.
1630     ///
1631     /// ```text
1632     /// error: pattern requires `..` due to inaccessible fields
1633     ///   --> src/main.rs:10:9
1634     ///    |
1635     /// LL |     let foo::Foo {} = foo::Foo::default();
1636     ///    |         ^^^^^^^^^^^
1637     ///    |
1638     /// help: add a `..`
1639     ///    |
1640     /// LL |     let foo::Foo { .. } = foo::Foo::default();
1641     ///    |                  ^^^^^^
1642     /// ```
1643     fn error_no_accessible_fields(
1644         &self,
1645         pat: &Pat<'_>,
1646         fields: &'tcx [hir::PatField<'tcx>],
1647     ) -> DiagnosticBuilder<'tcx, ErrorGuaranteed> {
1648         let mut err = self
1649             .tcx
1650             .sess
1651             .struct_span_err(pat.span, "pattern requires `..` due to inaccessible fields");
1652
1653         if let Some(field) = fields.last() {
1654             err.span_suggestion_verbose(
1655                 field.span.shrink_to_hi(),
1656                 "ignore the inaccessible and unused fields",
1657                 ", ..".to_string(),
1658                 Applicability::MachineApplicable,
1659             );
1660         } else {
1661             let qpath_span = if let PatKind::Struct(qpath, ..) = &pat.kind {
1662                 qpath.span()
1663             } else {
1664                 bug!("`error_no_accessible_fields` called on non-struct pattern");
1665             };
1666
1667             // Shrink the span to exclude the `foo:Foo` in `foo::Foo { }`.
1668             let span = pat.span.with_lo(qpath_span.shrink_to_hi().hi());
1669             err.span_suggestion_verbose(
1670                 span,
1671                 "ignore the inaccessible and unused fields",
1672                 " { .. }".to_string(),
1673                 Applicability::MachineApplicable,
1674             );
1675         }
1676         err
1677     }
1678
1679     /// Report that a pattern for a `#[non_exhaustive]` struct marked with `non_exhaustive_omitted_patterns`
1680     /// is not exhaustive enough.
1681     ///
1682     /// Nb: the partner lint for enums lives in `compiler/rustc_mir_build/src/thir/pattern/usefulness.rs`.
1683     fn lint_non_exhaustive_omitted_patterns(
1684         &self,
1685         pat: &Pat<'_>,
1686         unmentioned_fields: &[(&ty::FieldDef, Ident)],
1687         ty: Ty<'tcx>,
1688     ) {
1689         fn joined_uncovered_patterns(witnesses: &[&Ident]) -> String {
1690             const LIMIT: usize = 3;
1691             match witnesses {
1692                 [] => bug!(),
1693                 [witness] => format!("`{}`", witness),
1694                 [head @ .., tail] if head.len() < LIMIT => {
1695                     let head: Vec<_> = head.iter().map(<_>::to_string).collect();
1696                     format!("`{}` and `{}`", head.join("`, `"), tail)
1697                 }
1698                 _ => {
1699                     let (head, tail) = witnesses.split_at(LIMIT);
1700                     let head: Vec<_> = head.iter().map(<_>::to_string).collect();
1701                     format!("`{}` and {} more", head.join("`, `"), tail.len())
1702                 }
1703             }
1704         }
1705         let joined_patterns = joined_uncovered_patterns(
1706             &unmentioned_fields.iter().map(|(_, i)| i).collect::<Vec<_>>(),
1707         );
1708
1709         self.tcx.struct_span_lint_hir(NON_EXHAUSTIVE_OMITTED_PATTERNS, pat.hir_id, pat.span, |build| {
1710         let mut lint = build.build("some fields are not explicitly listed");
1711         lint.span_label(pat.span, format!("field{} {} not listed", rustc_errors::pluralize!(unmentioned_fields.len()), joined_patterns));
1712
1713         lint.help(
1714             "ensure that all fields are mentioned explicitly by adding the suggested fields",
1715         );
1716         lint.note(&format!(
1717             "the pattern is of type `{}` and the `non_exhaustive_omitted_patterns` attribute was found",
1718             ty,
1719         ));
1720         lint.emit();
1721     });
1722     }
1723
1724     /// Returns a diagnostic reporting a struct pattern which does not mention some fields.
1725     ///
1726     /// ```text
1727     /// error[E0027]: pattern does not mention field `bar`
1728     ///   --> src/main.rs:15:9
1729     ///    |
1730     /// LL |     let foo::Foo {} = foo::Foo::new();
1731     ///    |         ^^^^^^^^^^^ missing field `bar`
1732     /// ```
1733     fn error_unmentioned_fields(
1734         &self,
1735         pat: &Pat<'_>,
1736         unmentioned_fields: &[(&ty::FieldDef, Ident)],
1737         have_inaccessible_fields: bool,
1738         fields: &'tcx [hir::PatField<'tcx>],
1739     ) -> DiagnosticBuilder<'tcx, ErrorGuaranteed> {
1740         let inaccessible = if have_inaccessible_fields { " and inaccessible fields" } else { "" };
1741         let field_names = if unmentioned_fields.len() == 1 {
1742             format!("field `{}`{}", unmentioned_fields[0].1, inaccessible)
1743         } else {
1744             let fields = unmentioned_fields
1745                 .iter()
1746                 .map(|(_, name)| format!("`{}`", name))
1747                 .collect::<Vec<String>>()
1748                 .join(", ");
1749             format!("fields {}{}", fields, inaccessible)
1750         };
1751         let mut err = struct_span_err!(
1752             self.tcx.sess,
1753             pat.span,
1754             E0027,
1755             "pattern does not mention {}",
1756             field_names
1757         );
1758         err.span_label(pat.span, format!("missing {}", field_names));
1759         let len = unmentioned_fields.len();
1760         let (prefix, postfix, sp) = match fields {
1761             [] => match &pat.kind {
1762                 PatKind::Struct(path, [], false) => {
1763                     (" { ", " }", path.span().shrink_to_hi().until(pat.span.shrink_to_hi()))
1764                 }
1765                 _ => return err,
1766             },
1767             [.., field] => {
1768                 // Account for last field having a trailing comma or parse recovery at the tail of
1769                 // the pattern to avoid invalid suggestion (#78511).
1770                 let tail = field.span.shrink_to_hi().with_hi(pat.span.hi());
1771                 match &pat.kind {
1772                     PatKind::Struct(..) => (", ", " }", tail),
1773                     _ => return err,
1774                 }
1775             }
1776         };
1777         err.span_suggestion(
1778             sp,
1779             &format!(
1780                 "include the missing field{} in the pattern{}",
1781                 pluralize!(len),
1782                 if have_inaccessible_fields { " and ignore the inaccessible fields" } else { "" }
1783             ),
1784             format!(
1785                 "{}{}{}{}",
1786                 prefix,
1787                 unmentioned_fields
1788                     .iter()
1789                     .map(|(_, name)| name.to_string())
1790                     .collect::<Vec<_>>()
1791                     .join(", "),
1792                 if have_inaccessible_fields { ", .." } else { "" },
1793                 postfix,
1794             ),
1795             Applicability::MachineApplicable,
1796         );
1797         err.span_suggestion(
1798             sp,
1799             &format!(
1800                 "if you don't care about {these} missing field{s}, you can explicitly ignore {them}",
1801                 these = pluralize!("this", len),
1802                 s = pluralize!(len),
1803                 them = if len == 1 { "it" } else { "them" },
1804             ),
1805             format!("{}..{}", prefix, postfix),
1806             Applicability::MachineApplicable,
1807         );
1808         err
1809     }
1810
1811     fn check_pat_box(
1812         &self,
1813         span: Span,
1814         inner: &'tcx Pat<'tcx>,
1815         expected: Ty<'tcx>,
1816         def_bm: BindingMode,
1817         ti: TopInfo<'tcx>,
1818     ) -> Ty<'tcx> {
1819         let tcx = self.tcx;
1820         let (box_ty, inner_ty) = if self.check_dereferenceable(span, expected, inner) {
1821             // Here, `demand::subtype` is good enough, but I don't
1822             // think any errors can be introduced by using `demand::eqtype`.
1823             let inner_ty = self.next_ty_var(TypeVariableOrigin {
1824                 kind: TypeVariableOriginKind::TypeInference,
1825                 span: inner.span,
1826             });
1827             let box_ty = tcx.mk_box(inner_ty);
1828             self.demand_eqtype_pat(span, expected, box_ty, ti);
1829             (box_ty, inner_ty)
1830         } else {
1831             let err = tcx.ty_error();
1832             (err, err)
1833         };
1834         self.check_pat(inner, inner_ty, def_bm, ti);
1835         box_ty
1836     }
1837
1838     fn check_pat_ref(
1839         &self,
1840         pat: &'tcx Pat<'tcx>,
1841         inner: &'tcx Pat<'tcx>,
1842         mutbl: hir::Mutability,
1843         expected: Ty<'tcx>,
1844         def_bm: BindingMode,
1845         ti: TopInfo<'tcx>,
1846     ) -> Ty<'tcx> {
1847         let tcx = self.tcx;
1848         let expected = self.shallow_resolve(expected);
1849         let (rptr_ty, inner_ty) = if self.check_dereferenceable(pat.span, expected, inner) {
1850             // `demand::subtype` would be good enough, but using `eqtype` turns
1851             // out to be equally general. See (note_1) for details.
1852
1853             // Take region, inner-type from expected type if we can,
1854             // to avoid creating needless variables. This also helps with
1855             // the bad  interactions of the given hack detailed in (note_1).
1856             debug!("check_pat_ref: expected={:?}", expected);
1857             match *expected.kind() {
1858                 ty::Ref(_, r_ty, r_mutbl) if r_mutbl == mutbl => (expected, r_ty),
1859                 _ => {
1860                     let inner_ty = self.next_ty_var(TypeVariableOrigin {
1861                         kind: TypeVariableOriginKind::TypeInference,
1862                         span: inner.span,
1863                     });
1864                     let rptr_ty = self.new_ref_ty(pat.span, mutbl, inner_ty);
1865                     debug!("check_pat_ref: demanding {:?} = {:?}", expected, rptr_ty);
1866                     let err = self.demand_eqtype_pat_diag(pat.span, expected, rptr_ty, ti);
1867
1868                     // Look for a case like `fn foo(&foo: u32)` and suggest
1869                     // `fn foo(foo: &u32)`
1870                     if let Some(mut err) = err {
1871                         self.borrow_pat_suggestion(&mut err, pat, inner, expected);
1872                         err.emit();
1873                     }
1874                     (rptr_ty, inner_ty)
1875                 }
1876             }
1877         } else {
1878             let err = tcx.ty_error();
1879             (err, err)
1880         };
1881         self.check_pat(inner, inner_ty, def_bm, TopInfo { parent_pat: Some(pat), ..ti });
1882         rptr_ty
1883     }
1884
1885     /// Create a reference type with a fresh region variable.
1886     fn new_ref_ty(&self, span: Span, mutbl: hir::Mutability, ty: Ty<'tcx>) -> Ty<'tcx> {
1887         let region = self.next_region_var(infer::PatternRegion(span));
1888         let mt = ty::TypeAndMut { ty, mutbl };
1889         self.tcx.mk_ref(region, mt)
1890     }
1891
1892     /// Type check a slice pattern.
1893     ///
1894     /// Syntactically, these look like `[pat_0, ..., pat_n]`.
1895     /// Semantically, we are type checking a pattern with structure:
1896     /// ```
1897     /// [before_0, ..., before_n, (slice, after_0, ... after_n)?]
1898     /// ```
1899     /// The type of `slice`, if it is present, depends on the `expected` type.
1900     /// If `slice` is missing, then so is `after_i`.
1901     /// If `slice` is present, it can still represent 0 elements.
1902     fn check_pat_slice(
1903         &self,
1904         span: Span,
1905         before: &'tcx [Pat<'tcx>],
1906         slice: Option<&'tcx Pat<'tcx>>,
1907         after: &'tcx [Pat<'tcx>],
1908         expected: Ty<'tcx>,
1909         def_bm: BindingMode,
1910         ti: TopInfo<'tcx>,
1911     ) -> Ty<'tcx> {
1912         let expected = self.structurally_resolved_type(span, expected);
1913         let (element_ty, opt_slice_ty, inferred) = match *expected.kind() {
1914             // An array, so we might have something like `let [a, b, c] = [0, 1, 2];`.
1915             ty::Array(element_ty, len) => {
1916                 let min = before.len() as u64 + after.len() as u64;
1917                 let (opt_slice_ty, expected) =
1918                     self.check_array_pat_len(span, element_ty, expected, slice, len, min);
1919                 // `opt_slice_ty.is_none()` => `slice.is_none()`.
1920                 // Note, though, that opt_slice_ty could be `Some(error_ty)`.
1921                 assert!(opt_slice_ty.is_some() || slice.is_none());
1922                 (element_ty, opt_slice_ty, expected)
1923             }
1924             ty::Slice(element_ty) => (element_ty, Some(expected), expected),
1925             // The expected type must be an array or slice, but was neither, so error.
1926             _ => {
1927                 if !expected.references_error() {
1928                     self.error_expected_array_or_slice(span, expected, ti);
1929                 }
1930                 let err = self.tcx.ty_error();
1931                 (err, Some(err), err)
1932             }
1933         };
1934
1935         // Type check all the patterns before `slice`.
1936         for elt in before {
1937             self.check_pat(elt, element_ty, def_bm, ti);
1938         }
1939         // Type check the `slice`, if present, against its expected type.
1940         if let Some(slice) = slice {
1941             self.check_pat(slice, opt_slice_ty.unwrap(), def_bm, ti);
1942         }
1943         // Type check the elements after `slice`, if present.
1944         for elt in after {
1945             self.check_pat(elt, element_ty, def_bm, ti);
1946         }
1947         inferred
1948     }
1949
1950     /// Type check the length of an array pattern.
1951     ///
1952     /// Returns both the type of the variable length pattern (or `None`), and the potentially
1953     /// inferred array type. We only return `None` for the slice type if `slice.is_none()`.
1954     fn check_array_pat_len(
1955         &self,
1956         span: Span,
1957         element_ty: Ty<'tcx>,
1958         arr_ty: Ty<'tcx>,
1959         slice: Option<&'tcx Pat<'tcx>>,
1960         len: ty::Const<'tcx>,
1961         min_len: u64,
1962     ) -> (Option<Ty<'tcx>>, Ty<'tcx>) {
1963         if let Some(len) = len.try_eval_usize(self.tcx, self.param_env) {
1964             // Now we know the length...
1965             if slice.is_none() {
1966                 // ...and since there is no variable-length pattern,
1967                 // we require an exact match between the number of elements
1968                 // in the array pattern and as provided by the matched type.
1969                 if min_len == len {
1970                     return (None, arr_ty);
1971                 }
1972
1973                 self.error_scrutinee_inconsistent_length(span, min_len, len);
1974             } else if let Some(pat_len) = len.checked_sub(min_len) {
1975                 // The variable-length pattern was there,
1976                 // so it has an array type with the remaining elements left as its size...
1977                 return (Some(self.tcx.mk_array(element_ty, pat_len)), arr_ty);
1978             } else {
1979                 // ...however, in this case, there were no remaining elements.
1980                 // That is, the slice pattern requires more than the array type offers.
1981                 self.error_scrutinee_with_rest_inconsistent_length(span, min_len, len);
1982             }
1983         } else if slice.is_none() {
1984             // We have a pattern with a fixed length,
1985             // which we can use to infer the length of the array.
1986             let updated_arr_ty = self.tcx.mk_array(element_ty, min_len);
1987             self.demand_eqtype(span, updated_arr_ty, arr_ty);
1988             return (None, updated_arr_ty);
1989         } else {
1990             // We have a variable-length pattern and don't know the array length.
1991             // This happens if we have e.g.,
1992             // `let [a, b, ..] = arr` where `arr: [T; N]` where `const N: usize`.
1993             self.error_scrutinee_unfixed_length(span);
1994         }
1995
1996         // If we get here, we must have emitted an error.
1997         (Some(self.tcx.ty_error()), arr_ty)
1998     }
1999
2000     fn error_scrutinee_inconsistent_length(&self, span: Span, min_len: u64, size: u64) {
2001         struct_span_err!(
2002             self.tcx.sess,
2003             span,
2004             E0527,
2005             "pattern requires {} element{} but array has {}",
2006             min_len,
2007             pluralize!(min_len),
2008             size,
2009         )
2010         .span_label(span, format!("expected {} element{}", size, pluralize!(size)))
2011         .emit();
2012     }
2013
2014     fn error_scrutinee_with_rest_inconsistent_length(&self, span: Span, min_len: u64, size: u64) {
2015         struct_span_err!(
2016             self.tcx.sess,
2017             span,
2018             E0528,
2019             "pattern requires at least {} element{} but array has {}",
2020             min_len,
2021             pluralize!(min_len),
2022             size,
2023         )
2024         .span_label(
2025             span,
2026             format!("pattern cannot match array of {} element{}", size, pluralize!(size),),
2027         )
2028         .emit();
2029     }
2030
2031     fn error_scrutinee_unfixed_length(&self, span: Span) {
2032         struct_span_err!(
2033             self.tcx.sess,
2034             span,
2035             E0730,
2036             "cannot pattern-match on an array without a fixed length",
2037         )
2038         .emit();
2039     }
2040
2041     fn error_expected_array_or_slice(&self, span: Span, expected_ty: Ty<'tcx>, ti: TopInfo<'tcx>) {
2042         let mut err = struct_span_err!(
2043             self.tcx.sess,
2044             span,
2045             E0529,
2046             "expected an array or slice, found `{}`",
2047             expected_ty
2048         );
2049         if let ty::Ref(_, ty, _) = expected_ty.kind() {
2050             if let ty::Array(..) | ty::Slice(..) = ty.kind() {
2051                 err.help("the semantics of slice patterns changed recently; see issue #62254");
2052             }
2053         } else if Autoderef::new(&self.infcx, self.param_env, self.body_id, span, expected_ty, span)
2054             .any(|(ty, _)| matches!(ty.kind(), ty::Slice(..) | ty::Array(..)))
2055         {
2056             if let (Some(span), true) = (ti.span, ti.origin_expr) {
2057                 if let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(span) {
2058                     let applicability = Autoderef::new(
2059                         &self.infcx,
2060                         self.param_env,
2061                         self.body_id,
2062                         span,
2063                         self.resolve_vars_if_possible(ti.expected),
2064                         span,
2065                     )
2066                     .find_map(|(ty, _)| {
2067                         match ty.kind() {
2068                             ty::Adt(adt_def, _)
2069                                 if self.tcx.is_diagnostic_item(sym::Option, adt_def.did())
2070                                     || self.tcx.is_diagnostic_item(sym::Result, adt_def.did()) =>
2071                             {
2072                                 // Slicing won't work here, but `.as_deref()` might (issue #91328).
2073                                 err.span_suggestion(
2074                                     span,
2075                                     "consider using `as_deref` here",
2076                                     format!("{}.as_deref()", snippet),
2077                                     Applicability::MaybeIncorrect,
2078                                 );
2079                                 Some(None)
2080                             }
2081
2082                             ty::Slice(..) | ty::Array(..) => {
2083                                 Some(Some(Applicability::MachineApplicable))
2084                             }
2085
2086                             _ => None,
2087                         }
2088                     })
2089                     .unwrap_or(Some(Applicability::MaybeIncorrect));
2090
2091                     if let Some(applicability) = applicability {
2092                         err.span_suggestion(
2093                             span,
2094                             "consider slicing here",
2095                             format!("{}[..]", snippet),
2096                             applicability,
2097                         );
2098                     }
2099                 }
2100             }
2101         }
2102         err.span_label(span, format!("pattern cannot match with input type `{}`", expected_ty));
2103         err.emit();
2104     }
2105 }