src/libsyntax/parse/parser/pat.rs

   1 use super::{Parser, PResult, PathStyle};
   2
   3 use crate::{maybe_recover_from_interpolated_ty_qpath, maybe_whole};
   4 use crate::ptr::P;
   5 use crate::ast::{self, Attribute, Pat, PatKind, FieldPat, RangeEnd, RangeSyntax, Mac_};
   6 use crate::ast::{BindingMode, Ident, Mutability, Path, QSelf, Expr, ExprKind};
   7 use crate::parse::token::{self};
   8 use crate::print::pprust;
   9 use crate::source_map::{respan, Span, Spanned};
  10 use crate::symbol::kw;
  11 use crate::ThinVec;
  12
  13 use errors::{Applicability, DiagnosticBuilder};
  14
  15 impl<'a> Parser<'a> {
  16     /// Parses a pattern.
  17     pub fn parse_pat(&mut self, expected: Option<&'static str>) -> PResult<'a, P<Pat>> {
  18         self.parse_pat_with_range_pat(true, expected)
  19     }
  20
  21     /// Parses patterns, separated by '|' s.
  22     pub(super) fn parse_pats(&mut self) -> PResult<'a, Vec<P<Pat>>> {
  23         // Allow a '|' before the pats (RFC 1925 + RFC 2530)
  24         self.eat(&token::BinOp(token::Or));
  25
  26         let mut pats = Vec::new();
  27         loop {
  28             pats.push(self.parse_top_level_pat()?);
  29
  30             if self.token == token::OrOr {
  31                 self.struct_span_err(self.token.span, "unexpected token `||` after pattern")
  32                     .span_suggestion(
  33                         self.token.span,
  34                         "use a single `|` to specify multiple patterns",
  35                         "|".to_owned(),
  36                         Applicability::MachineApplicable
  37                     )
  38                     .emit();
  39                 self.bump();
  40             } else if self.eat(&token::BinOp(token::Or)) {
  41                 // This is a No-op. Continue the loop to parse the next
  42                 // pattern.
  43             } else {
  44                 return Ok(pats);
  45             }
  46         };
  47     }
  48
  49     /// A wrapper around `parse_pat` with some special error handling for the
  50     /// "top-level" patterns in a match arm, `for` loop, `let`, &c. (in contrast
  51     /// to subpatterns within such).
  52     pub(super) fn parse_top_level_pat(&mut self) -> PResult<'a, P<Pat>> {
  53         let pat = self.parse_pat(None)?;
  54         if self.token == token::Comma {
  55             // An unexpected comma after a top-level pattern is a clue that the
  56             // user (perhaps more accustomed to some other language) forgot the
  57             // parentheses in what should have been a tuple pattern; return a
  58             // suggestion-enhanced error here rather than choking on the comma
  59             // later.
  60             let comma_span = self.token.span;
  61             self.bump();
  62             if let Err(mut err) = self.skip_pat_list() {
  63                 // We didn't expect this to work anyway; we just wanted
  64                 // to advance to the end of the comma-sequence so we know
  65                 // the span to suggest parenthesizing
  66                 err.cancel();
  67             }
  68             let seq_span = pat.span.to(self.prev_span);
  69             let mut err = self.struct_span_err(comma_span, "unexpected `,` in pattern");
  70             if let Ok(seq_snippet) = self.span_to_snippet(seq_span) {
  71                 err.span_suggestion(
  72                     seq_span,
  73                     "try adding parentheses to match on a tuple..",
  74                     format!("({})", seq_snippet),
  75                     Applicability::MachineApplicable
  76                 ).span_suggestion(
  77                     seq_span,
  78                     "..or a vertical bar to match on multiple alternatives",
  79                     format!("{}", seq_snippet.replace(",", " |")),
  80                     Applicability::MachineApplicable
  81                 );
  82             }
  83             return Err(err);
  84         }
  85         Ok(pat)
  86     }
  87
  88     /// Parse and throw away a parentesized comma separated
  89     /// sequence of patterns until `)` is reached.
  90     fn skip_pat_list(&mut self) -> PResult<'a, ()> {
  91         while !self.check(&token::CloseDelim(token::Paren)) {
  92             self.parse_pat(None)?;
  93             if !self.eat(&token::Comma) {
  94                 return Ok(())
  95             }
  96         }
  97         Ok(())
  98     }
  99
 100     /// Parses a pattern, with a setting whether modern range patterns (e.g., `a..=b`, `a..b` are
 101     /// allowed).
 102     fn parse_pat_with_range_pat(
 103         &mut self,
 104         allow_range_pat: bool,
 105         expected: Option<&'static str>,
 106     ) -> PResult<'a, P<Pat>> {
 107         maybe_recover_from_interpolated_ty_qpath!(self, true);
 108         maybe_whole!(self, NtPat, |x| x);
 109
 110         let lo = self.token.span;
 111         let pat = match self.token.kind {
 112             token::BinOp(token::And) | token::AndAnd => self.parse_pat_deref(expected)?,
 113             token::OpenDelim(token::Paren) => self.parse_pat_tuple_or_parens()?,
 114             token::OpenDelim(token::Bracket) => {
 115                 // Parse `[pat, pat,...]` as a slice pattern.
 116                 PatKind::Slice(self.parse_delim_comma_seq(token::Bracket, |p| p.parse_pat(None))?.0)
 117             }
 118             token::DotDot => {
 119                 self.bump();
 120                 if self.is_pat_range_end_start() {
 121                     // Parse `..42` for recovery.
 122                     self.parse_pat_range_to(RangeEnd::Excluded, "..")?
 123                 } else {
 124                     // A rest pattern `..`.
 125                     PatKind::Rest
 126                 }
 127             }
 128             token::DotDotEq => {
 129                 // Parse `..=42` for recovery.
 130                 self.bump();
 131                 self.parse_pat_range_to(RangeEnd::Included(RangeSyntax::DotDotEq), "..=")?
 132             }
 133             token::DotDotDot => {
 134                 // Parse `...42` for recovery.
 135                 self.bump();
 136                 self.parse_pat_range_to(RangeEnd::Included(RangeSyntax::DotDotDot), "...")?
 137             }
 138             // At this point, token != &, &&, (, [
 139             _ => if self.eat_keyword(kw::Underscore) {
 140                 // Parse _
 141                 PatKind::Wild
 142             } else if self.eat_keyword(kw::Mut) {
 143                 self.recover_pat_ident_mut_first()?
 144             } else if self.eat_keyword(kw::Ref) {
 145                 // Parse ref ident @ pat / ref mut ident @ pat
 146                 let mutbl = self.parse_mutability();
 147                 self.parse_pat_ident(BindingMode::ByRef(mutbl))?
 148             } else if self.eat_keyword(kw::Box) {
 149                 // Parse `box pat`
 150                 PatKind::Box(self.parse_pat_with_range_pat(false, None)?)
 151             } else if self.token.is_ident() && !self.token.is_reserved_ident() &&
 152                       self.parse_as_ident() {
 153                 // Parse `ident @ pat`
 154                 // This can give false positives and parse nullary enums,
 155                 // they are dealt with later in resolve.
 156                 self.parse_pat_ident(BindingMode::ByValue(Mutability::Immutable))?
 157             } else if self.token.is_path_start() {
 158                 // Parse pattern starting with a path
 159                 let (qself, path) = if self.eat_lt() {
 160                     // Parse a qualified path
 161                     let (qself, path) = self.parse_qpath(PathStyle::Expr)?;
 162                     (Some(qself), path)
 163                 } else {
 164                     // Parse an unqualified path
 165                     (None, self.parse_path(PathStyle::Expr)?)
 166                 };
 167                 match self.token.kind {
 168                     token::Not if qself.is_none() => self.parse_pat_mac_invoc(lo, path)?,
 169                     token::DotDotDot | token::DotDotEq | token::DotDot => {
 170                         self.parse_pat_range_starting_with_path(lo, qself, path)?
 171                     }
 172                     token::OpenDelim(token::Brace) => self.parse_pat_struct(qself, path)?,
 173                     token::OpenDelim(token::Paren) => self.parse_pat_tuple_struct(qself, path)?,
 174                     _ => PatKind::Path(qself, path),
 175                 }
 176             } else {
 177                 // Try to parse everything else as literal with optional minus
 178                 match self.parse_literal_maybe_minus() {
 179                     Ok(begin)
 180                         if self.check(&token::DotDot)
 181                             || self.check(&token::DotDotEq)
 182                             || self.check(&token::DotDotDot) =>
 183                     {
 184                         self.parse_pat_range_starting_with_lit(begin)?
 185                     }
 186                     Ok(begin) => PatKind::Lit(begin),
 187                     Err(err) => return self.fatal_unexpected_non_pat(err, expected),
 188                 }
 189             }
 190         };
 191
 192         let pat = self.mk_pat(lo.to(self.prev_span), pat);
 193         let pat = self.maybe_recover_from_bad_qpath(pat, true)?;
 194
 195         if !allow_range_pat {
 196             self.ban_pat_range_if_ambiguous(&pat)?
 197         }
 198
 199         Ok(pat)
 200     }
 201
 202     /// Ban a range pattern if it has an ambiguous interpretation.
 203     fn ban_pat_range_if_ambiguous(&self, pat: &Pat) -> PResult<'a, ()> {
 204         match pat.node {
 205             PatKind::Range(
 206                 .., Spanned { node: RangeEnd::Included(RangeSyntax::DotDotDot), .. }
 207             ) => return Ok(()),
 208             PatKind::Range(..) => {}
 209             _ => return Ok(()),
 210         }
 211
 212         let mut err = self.struct_span_err(
 213             pat.span,
 214             "the range pattern here has ambiguous interpretation",
 215         );
 216         err.span_suggestion(
 217             pat.span,
 218             "add parentheses to clarify the precedence",
 219             format!("({})", pprust::pat_to_string(&pat)),
 220             // "ambiguous interpretation" implies that we have to be guessing
 221             Applicability::MaybeIncorrect
 222         );
 223         Err(err)
 224     }
 225
 226     /// Parse `&pat` / `&mut pat`.
 227     fn parse_pat_deref(&mut self, expected: Option<&'static str>) -> PResult<'a, PatKind> {
 228         self.expect_and()?;
 229         let mutbl = self.parse_mutability();
 230
 231         if let token::Lifetime(name) = self.token.kind {
 232             let mut err = self.fatal(&format!("unexpected lifetime `{}` in pattern", name));
 233             err.span_label(self.token.span, "unexpected lifetime");
 234             return Err(err);
 235         }
 236
 237         let subpat = self.parse_pat_with_range_pat(false, expected)?;
 238         Ok(PatKind::Ref(subpat, mutbl))
 239     }
 240
 241     /// Parse a tuple or parenthesis pattern.
 242     fn parse_pat_tuple_or_parens(&mut self) -> PResult<'a, PatKind> {
 243         let (fields, trailing_comma) = self.parse_paren_comma_seq(|p| p.parse_pat(None))?;
 244
 245         // Here, `(pat,)` is a tuple pattern.
 246         // For backward compatibility, `(..)` is a tuple pattern as well.
 247         Ok(if fields.len() == 1 && !(trailing_comma || fields[0].is_rest()) {
 248             PatKind::Paren(fields.into_iter().nth(0).unwrap())
 249         } else {
 250             PatKind::Tuple(fields)
 251         })
 252     }
 253
 254     /// Recover on `mut ref? ident @ pat` and suggest
 255     /// that the order of `mut` and `ref` is incorrect.
 256     fn recover_pat_ident_mut_first(&mut self) -> PResult<'a, PatKind> {
 257         let mutref_span = self.prev_span.to(self.token.span);
 258         let binding_mode = if self.eat_keyword(kw::Ref) {
 259             self.struct_span_err(mutref_span, "the order of `mut` and `ref` is incorrect")
 260                 .span_suggestion(
 261                     mutref_span,
 262                     "try switching the order",
 263                     "ref mut".into(),
 264                     Applicability::MachineApplicable
 265                 )
 266                 .emit();
 267             BindingMode::ByRef(Mutability::Mutable)
 268         } else {
 269             BindingMode::ByValue(Mutability::Mutable)
 270         };
 271         self.parse_pat_ident(binding_mode)
 272     }
 273
 274     /// Parse macro invocation
 275     fn parse_pat_mac_invoc(&mut self, lo: Span, path: Path) -> PResult<'a, PatKind> {
 276         self.bump();
 277         let (delim, tts) = self.expect_delimited_token_tree()?;
 278         let mac = respan(lo.to(self.prev_span), Mac_ {
 279             path,
 280             tts,
 281             delim,
 282             prior_type_ascription: self.last_type_ascription,
 283         });
 284         Ok(PatKind::Mac(mac))
 285     }
 286
 287     /// Parse a range pattern `$path $form $end?` where `$form = ".." | "..." | "..=" ;`.
 288     /// The `$path` has already been parsed and the next token is the `$form`.
 289     fn parse_pat_range_starting_with_path(
 290         &mut self,
 291         lo: Span,
 292         qself: Option<QSelf>,
 293         path: Path
 294     ) -> PResult<'a, PatKind> {
 295         let (end_kind, form) = match self.token.kind {
 296             token::DotDot => (RangeEnd::Excluded, ".."),
 297             token::DotDotDot => (RangeEnd::Included(RangeSyntax::DotDotDot), "..."),
 298             token::DotDotEq => (RangeEnd::Included(RangeSyntax::DotDotEq), "..="),
 299             _ => panic!("can only parse `..`/`...`/`..=` for ranges (checked above)"),
 300         };
 301         let op_span = self.token.span;
 302         // Parse range
 303         let span = lo.to(self.prev_span);
 304         let begin = self.mk_expr(span, ExprKind::Path(qself, path), ThinVec::new());
 305         self.bump();
 306         let end = self.parse_pat_range_end_opt(&begin, form)?;
 307         Ok(PatKind::Range(begin, end, respan(op_span, end_kind)))
 308     }
 309
 310     /// Parse a range pattern `$literal $form $end?` where `$form = ".." | "..." | "..=" ;`.
 311     /// The `$path` has already been parsed and the next token is the `$form`.
 312     fn parse_pat_range_starting_with_lit(&mut self, begin: P<Expr>) -> PResult<'a, PatKind> {
 313         let op_span = self.token.span;
 314         let (end_kind, form) = if self.eat(&token::DotDotDot) {
 315             (RangeEnd::Included(RangeSyntax::DotDotDot), "...")
 316         } else if self.eat(&token::DotDotEq) {
 317             (RangeEnd::Included(RangeSyntax::DotDotEq), "..=")
 318         } else if self.eat(&token::DotDot) {
 319             (RangeEnd::Excluded, "..")
 320         } else {
 321             panic!("impossible case: we already matched on a range-operator token")
 322         };
 323         let end = self.parse_pat_range_end_opt(&begin, form)?;
 324         Ok(PatKind::Range(begin, end, respan(op_span, end_kind)))
 325     }
 326
 327     fn fatal_unexpected_non_pat(
 328         &mut self,
 329         mut err: DiagnosticBuilder<'a>,
 330         expected: Option<&'static str>,
 331     ) -> PResult<'a, P<Pat>> {
 332         self.cancel(&mut err);
 333
 334         let expected = expected.unwrap_or("pattern");
 335         let msg = format!("expected {}, found {}", expected, self.this_token_descr());
 336
 337         let mut err = self.fatal(&msg);
 338         err.span_label(self.token.span, format!("expected {}", expected));
 339
 340         let sp = self.sess.source_map().start_point(self.token.span);
 341         if let Some(sp) = self.sess.ambiguous_block_expr_parse.borrow().get(&sp) {
 342             self.sess.expr_parentheses_needed(&mut err, *sp, None);
 343         }
 344
 345         Err(err)
 346     }
 347
 348     // Helper function to decide whether to parse as ident binding
 349     // or to try to do something more complex like range patterns.
 350     fn parse_as_ident(&mut self) -> bool {
 351         self.look_ahead(1, |t| match t.kind {
 352             token::OpenDelim(token::Paren) | token::OpenDelim(token::Brace) |
 353             token::DotDotDot | token::DotDotEq | token::DotDot |
 354             token::ModSep | token::Not => false,
 355             _ => true,
 356         })
 357     }
 358
 359     /// Is the current token suitable as the start of a range patterns end?
 360     fn is_pat_range_end_start(&self) -> bool {
 361         self.token.is_path_start() // e.g. `MY_CONST`;
 362             || self.token == token::Dot // e.g. `.5` for recovery;
 363             || self.token.can_begin_literal_or_bool() // e.g. `42`.
 364             || self.token.is_whole_expr()
 365     }
 366
 367     /// Parse a range-to pattern, e.g. `..X` and `..=X` for recovery.
 368     fn parse_pat_range_to(&mut self, re: RangeEnd, form: &str) -> PResult<'a, PatKind> {
 369         let lo = self.prev_span;
 370         let end = self.parse_pat_range_end()?;
 371         let range_span = lo.to(end.span);
 372         let begin = self.mk_expr(range_span, ExprKind::Err, ThinVec::new());
 373
 374         self.diagnostic()
 375             .struct_span_err(range_span, &format!("`{}X` range patterns are not supported", form))
 376             .span_suggestion(
 377                 range_span,
 378                 "try using the minimum value for the type",
 379                 format!("MIN{}{}", form, pprust::expr_to_string(&end)),
 380                 Applicability::HasPlaceholders,
 381             )
 382             .emit();
 383
 384         Ok(PatKind::Range(begin, end, respan(lo, re)))
 385     }
 386
 387     /// Parse the end of a `X..Y`, `X..=Y`, or `X...Y` range pattern  or recover
 388     /// if that end is missing treating it as `X..`, `X..=`, or `X...` respectively.
 389     fn parse_pat_range_end_opt(&mut self, begin: &Expr, form: &str) -> PResult<'a, P<Expr>> {
 390         if self.is_pat_range_end_start() {
 391             // Parsing e.g. `X..=Y`.
 392             self.parse_pat_range_end()
 393         } else {
 394             // Parsing e.g. `X..`.
 395             let range_span = begin.span.to(self.prev_span);
 396
 397             self.diagnostic()
 398                 .struct_span_err(
 399                     range_span,
 400                     &format!("`X{}` range patterns are not supported", form),
 401                 )
 402                 .span_suggestion(
 403                     range_span,
 404                     "try using the maximum value for the type",
 405                     format!("{}{}MAX", pprust::expr_to_string(&begin), form),
 406                     Applicability::HasPlaceholders,
 407                 )
 408                 .emit();
 409
 410             Ok(self.mk_expr(range_span, ExprKind::Err, ThinVec::new()))
 411         }
 412     }
 413
 414     fn parse_pat_range_end(&mut self) -> PResult<'a, P<Expr>> {
 415         if self.token.is_path_start() {
 416             let lo = self.token.span;
 417             let (qself, path) = if self.eat_lt() {
 418                 // Parse a qualified path
 419                 let (qself, path) = self.parse_qpath(PathStyle::Expr)?;
 420                 (Some(qself), path)
 421             } else {
 422                 // Parse an unqualified path
 423                 (None, self.parse_path(PathStyle::Expr)?)
 424             };
 425             let hi = self.prev_span;
 426             Ok(self.mk_expr(lo.to(hi), ExprKind::Path(qself, path), ThinVec::new()))
 427         } else {
 428             self.parse_literal_maybe_minus()
 429         }
 430     }
 431
 432     /// Parses `ident` or `ident @ pat`.
 433     /// Used by the copy foo and ref foo patterns to give a good
 434     /// error message when parsing mistakes like `ref foo(a, b)`.
 435     fn parse_pat_ident(&mut self, binding_mode: BindingMode) -> PResult<'a, PatKind> {
 436         let ident = self.parse_ident()?;
 437         let sub = if self.eat(&token::At) {
 438             Some(self.parse_pat(Some("binding pattern"))?)
 439         } else {
 440             None
 441         };
 442
 443         // Just to be friendly, if they write something like `ref Some(i)`,
 444         // we end up here with `(` as the current token.
 445         // This shortly leads to a parse error. Note that if there is no explicit
 446         // binding mode then we do not end up here, because the lookahead
 447         // will direct us over to `parse_enum_variant()`.
 448         if self.token == token::OpenDelim(token::Paren) {
 449             return Err(self.span_fatal(
 450                 self.prev_span,
 451                 "expected identifier, found enum pattern",
 452             ))
 453         }
 454
 455         Ok(PatKind::Ident(binding_mode, ident, sub))
 456     }
 457
 458     /// Parse a struct ("record") pattern (e.g. `Foo { ... }` or `Foo::Bar { ... }`).
 459     fn parse_pat_struct(&mut self, qself: Option<QSelf>, path: Path) -> PResult<'a, PatKind> {
 460         if qself.is_some() {
 461             let msg = "unexpected `{` after qualified path";
 462             let mut err = self.fatal(msg);
 463             err.span_label(self.token.span, msg);
 464             return Err(err);
 465         }
 466
 467         self.bump();
 468         let (fields, etc) = self.parse_pat_fields().unwrap_or_else(|mut e| {
 469             e.emit();
 470             self.recover_stmt();
 471             (vec![], true)
 472         });
 473         self.bump();
 474         Ok(PatKind::Struct(path, fields, etc))
 475     }
 476
 477     /// Parse tuple struct or tuple variant pattern (e.g. `Foo(...)` or `Foo::Bar(...)`).
 478     fn parse_pat_tuple_struct(&mut self, qself: Option<QSelf>, path: Path) -> PResult<'a, PatKind> {
 479         if qself.is_some() {
 480             let msg = "unexpected `(` after qualified path";
 481             let mut err = self.fatal(msg);
 482             err.span_label(self.token.span, msg);
 483             return Err(err);
 484         }
 485         let (fields, _) = self.parse_paren_comma_seq(|p| p.parse_pat(None))?;
 486         Ok(PatKind::TupleStruct(path, fields))
 487     }
 488
 489     /// Parses the fields of a struct-like pattern.
 490     fn parse_pat_fields(&mut self) -> PResult<'a, (Vec<Spanned<FieldPat>>, bool)> {
 491         let mut fields = Vec::new();
 492         let mut etc = false;
 493         let mut ate_comma = true;
 494         let mut delayed_err: Option<DiagnosticBuilder<'a>> = None;
 495         let mut etc_span = None;
 496
 497         while self.token != token::CloseDelim(token::Brace) {
 498             let attrs = match self.parse_outer_attributes() {
 499                 Ok(attrs) => attrs,
 500                 Err(err) => {
 501                     if let Some(mut delayed) = delayed_err {
 502                         delayed.emit();
 503                     }
 504                     return Err(err);
 505                 },
 506             };
 507             let lo = self.token.span;
 508
 509             // check that a comma comes after every field
 510             if !ate_comma {
 511                 let err = self.struct_span_err(self.prev_span, "expected `,`");
 512                 if let Some(mut delayed) = delayed_err {
 513                     delayed.emit();
 514                 }
 515                 return Err(err);
 516             }
 517             ate_comma = false;
 518
 519             if self.check(&token::DotDot) || self.token == token::DotDotDot {
 520                 etc = true;
 521                 let mut etc_sp = self.token.span;
 522
 523                 self.recover_one_fewer_dotdot();
 524                 self.bump();  // `..` || `...`
 525
 526                 if self.token == token::CloseDelim(token::Brace) {
 527                     etc_span = Some(etc_sp);
 528                     break;
 529                 }
 530                 let token_str = self.this_token_descr();
 531                 let mut err = self.fatal(&format!("expected `}}`, found {}", token_str));
 532
 533                 err.span_label(self.token.span, "expected `}`");
 534                 let mut comma_sp = None;
 535                 if self.token == token::Comma { // Issue #49257
 536                     let nw_span = self.sess.source_map().span_until_non_whitespace(self.token.span);
 537                     etc_sp = etc_sp.to(nw_span);
 538                     err.span_label(etc_sp,
 539                                    "`..` must be at the end and cannot have a trailing comma");
 540                     comma_sp = Some(self.token.span);
 541                     self.bump();
 542                     ate_comma = true;
 543                 }
 544
 545                 etc_span = Some(etc_sp.until(self.token.span));
 546                 if self.token == token::CloseDelim(token::Brace) {
 547                     // If the struct looks otherwise well formed, recover and continue.
 548                     if let Some(sp) = comma_sp {
 549                         err.span_suggestion_short(
 550                             sp,
 551                             "remove this comma",
 552                             String::new(),
 553                             Applicability::MachineApplicable,
 554                         );
 555                     }
 556                     err.emit();
 557                     break;
 558                 } else if self.token.is_ident() && ate_comma {
 559                     // Accept fields coming after `..,`.
 560                     // This way we avoid "pattern missing fields" errors afterwards.
 561                     // We delay this error until the end in order to have a span for a
 562                     // suggested fix.
 563                     if let Some(mut delayed_err) = delayed_err {
 564                         delayed_err.emit();
 565                         return Err(err);
 566                     } else {
 567                         delayed_err = Some(err);
 568                     }
 569                 } else {
 570                     if let Some(mut err) = delayed_err {
 571                         err.emit();
 572                     }
 573                     return Err(err);
 574                 }
 575             }
 576
 577             fields.push(match self.parse_pat_field(lo, attrs) {
 578                 Ok(field) => field,
 579                 Err(err) => {
 580                     if let Some(mut delayed_err) = delayed_err {
 581                         delayed_err.emit();
 582                     }
 583                     return Err(err);
 584                 }
 585             });
 586             ate_comma = self.eat(&token::Comma);
 587         }
 588
 589         if let Some(mut err) = delayed_err {
 590             if let Some(etc_span) = etc_span {
 591                 err.multipart_suggestion(
 592                     "move the `..` to the end of the field list",
 593                     vec![
 594                         (etc_span, String::new()),
 595                         (self.token.span, format!("{}.. }}", if ate_comma { "" } else { ", " })),
 596                     ],
 597                     Applicability::MachineApplicable,
 598                 );
 599             }
 600             err.emit();
 601         }
 602         return Ok((fields, etc));
 603     }
 604
 605     /// Recover on `...` as if it were `..` to avoid further errors.
 606     /// See issue #46718.
 607     fn recover_one_fewer_dotdot(&self) {
 608         if self.token != token::DotDotDot {
 609             return;
 610         }
 611
 612         self.struct_span_err(self.token.span, "expected field pattern, found `...`")
 613             .span_suggestion(
 614                 self.token.span,
 615                 "to omit remaining fields, use one fewer `.`",
 616                 "..".to_owned(),
 617                 Applicability::MachineApplicable
 618             )
 619             .emit();
 620     }
 621
 622     fn parse_pat_field(
 623         &mut self,
 624         lo: Span,
 625         attrs: Vec<Attribute>
 626     ) -> PResult<'a, Spanned<FieldPat>> {
 627         // Check if a colon exists one ahead. This means we're parsing a fieldname.
 628         let hi;
 629         let (subpat, fieldname, is_shorthand) = if self.look_ahead(1, |t| t == &token::Colon) {
 630             // Parsing a pattern of the form "fieldname: pat"
 631             let fieldname = self.parse_field_name()?;
 632             self.bump();
 633             let pat = self.parse_pat(None)?;
 634             hi = pat.span;
 635             (pat, fieldname, false)
 636         } else {
 637             // Parsing a pattern of the form "(box) (ref) (mut) fieldname"
 638             let is_box = self.eat_keyword(kw::Box);
 639             let boxed_span = self.token.span;
 640             let is_ref = self.eat_keyword(kw::Ref);
 641             let is_mut = self.eat_keyword(kw::Mut);
 642             let fieldname = self.parse_ident()?;
 643             hi = self.prev_span;
 644
 645             let bind_type = match (is_ref, is_mut) {
 646                 (true, true) => BindingMode::ByRef(Mutability::Mutable),
 647                 (true, false) => BindingMode::ByRef(Mutability::Immutable),
 648                 (false, true) => BindingMode::ByValue(Mutability::Mutable),
 649                 (false, false) => BindingMode::ByValue(Mutability::Immutable),
 650             };
 651
 652             let fieldpat = self.mk_pat_ident(boxed_span.to(hi), bind_type, fieldname);
 653             let subpat = if is_box {
 654                 self.mk_pat(lo.to(hi), PatKind::Box(fieldpat))
 655             } else {
 656                 fieldpat
 657             };
 658             (subpat, fieldname, true)
 659         };
 660
 661         Ok(Spanned {
 662             span: lo.to(hi),
 663             node: FieldPat {
 664                 ident: fieldname,
 665                 pat: subpat,
 666                 is_shorthand,
 667                 attrs: attrs.into(),
 668                 id: ast::DUMMY_NODE_ID,
 669            }
 670         })
 671     }
 672
 673     pub(super) fn mk_pat_ident(&self, span: Span, bm: BindingMode, ident: Ident) -> P<Pat> {
 674         self.mk_pat(span, PatKind::Ident(bm, ident, None))
 675     }
 676
 677     fn mk_pat(&self, span: Span, node: PatKind) -> P<Pat> {
 678         P(Pat { node, span, id: ast::DUMMY_NODE_ID })
 679     }
 680 }