use errors::{Applicability, DiagnosticBuilder};
+type Expected = Option<&'static str>;
+
impl<'a> Parser<'a> {
/// Parses a pattern.
- pub fn parse_pat(
- &mut self,
- expected: Option<&'static str>
- ) -> PResult<'a, P<Pat>> {
+ pub fn parse_pat(&mut self, expected: Expected) -> PResult<'a, P<Pat>> {
self.parse_pat_with_range_pat(true, expected)
}
- /// Parses patterns, separated by '|' s.
- pub(super) fn parse_pats(&mut self) -> PResult<'a, Vec<P<Pat>>> {
- // Allow a '|' before the pats (RFC 1925 + RFC 2530)
- self.eat(&token::BinOp(token::Or));
-
- let mut pats = Vec::new();
- loop {
- pats.push(self.parse_top_level_pat()?);
-
- if self.token == token::OrOr {
- self.struct_span_err(self.token.span, "unexpected token `||` after pattern")
- .span_suggestion(
- self.token.span,
- "use a single `|` to specify multiple patterns",
- "|".to_owned(),
- Applicability::MachineApplicable
- )
- .emit();
- self.bump();
- } else if self.eat(&token::BinOp(token::Or)) {
- // This is a No-op. Continue the loop to parse the next
- // pattern.
- } else {
- return Ok(pats);
- }
- };
+ // FIXME(or_patterns, Centril | dlrobertson):
+ // remove this and use `parse_top_pat` everywhere it is used instead.
+ pub(super) fn parse_top_pat_unpack(&mut self, gate_or: bool) -> PResult<'a, Vec<P<Pat>>> {
+ self.parse_top_pat(gate_or)
+ .map(|pat| pat.and_then(|pat| match pat.node {
+ PatKind::Or(pats) => pats,
+ node => vec![self.mk_pat(pat.span, node)],
+ }))
}
- /// A wrapper around `parse_pat` with some special error handling for the
- /// "top-level" patterns in a match arm, `for` loop, `let`, &c. (in contrast
- /// to subpatterns within such).
- pub(super) fn parse_top_level_pat(&mut self) -> PResult<'a, P<Pat>> {
- let pat = self.parse_pat(None)?;
- if self.token == token::Comma {
- // An unexpected comma after a top-level pattern is a clue that the
- // user (perhaps more accustomed to some other language) forgot the
- // parentheses in what should have been a tuple pattern; return a
- // suggestion-enhanced error here rather than choking on the comma
- // later.
- let comma_span = self.token.span;
- self.bump();
- if let Err(mut err) = self.skip_pat_list() {
- // We didn't expect this to work anyway; we just wanted
- // to advance to the end of the comma-sequence so we know
- // the span to suggest parenthesizing
- err.cancel();
- }
- let seq_span = pat.span.to(self.prev_span);
- let mut err = self.struct_span_err(comma_span, "unexpected `,` in pattern");
- if let Ok(seq_snippet) = self.span_to_snippet(seq_span) {
- err.span_suggestion(
- seq_span,
- "try adding parentheses to match on a tuple..",
- format!("({})", seq_snippet),
- Applicability::MachineApplicable
- ).span_suggestion(
- seq_span,
- "..or a vertical bar to match on multiple alternatives",
- format!("{}", seq_snippet.replace(",", " |")),
- Applicability::MachineApplicable
- );
- }
- return Err(err);
+ /// Entry point to the main pattern parser.
+ /// Corresponds to `top_pat` in RFC 2535 and allows or-pattern at the top level.
+ pub(super) fn parse_top_pat(&mut self, gate_or: bool) -> PResult<'a, P<Pat>> {
+ // Allow a '|' before the pats (RFCs 1925, 2530, and 2535).
+ if self.eat_or_separator() && gate_or {
+ self.sess.gated_spans.or_patterns.borrow_mut().push(self.prev_span);
}
- Ok(pat)
+
+ self.parse_pat_with_or(None, gate_or, true)
}
- /// Parse and throw away a parentesized comma separated
- /// sequence of patterns until `)` is reached.
- fn skip_pat_list(&mut self) -> PResult<'a, ()> {
- while !self.check(&token::CloseDelim(token::Paren)) {
- self.parse_pat(None)?;
- if !self.eat(&token::Comma) {
- return Ok(())
- }
- }
- Ok(())
+ pub(super) fn parse_top_level_pat(&mut self) -> PResult<'a, P<Pat>> {
+ let pat = self.parse_pat(None)?;
+ self.maybe_recover_unexpected_comma(pat.span, true)?;
+ Ok(pat)
}
- /// Parses a pattern, that may be a or-pattern (e.g. `Some(Foo | Bar)`).
- fn parse_pat_with_or(&mut self, expected: Option<&'static str>) -> PResult<'a, P<Pat>> {
+ /// Parses a pattern, that may be a or-pattern (e.g. `Foo | Bar` in `Some(Foo | Bar)`).
+ /// Corresponds to `pat<allow_top_alt>` in RFC 2535.
+ fn parse_pat_with_or(
+ &mut self,
+ expected: Expected,
+ gate_or: bool,
+ top_level: bool
+ ) -> PResult<'a, P<Pat>> {
// Parse the first pattern.
let first_pat = self.parse_pat(expected)?;
+ self.maybe_recover_unexpected_comma(first_pat.span, top_level)?;
- // If the next token is not a `|`, this is not an or-pattern and
- // we should exit here.
- if !self.check(&token::BinOp(token::Or)) {
+ // If the next token is not a `|`,
+ // this is not an or-pattern and we should exit here.
+ if !self.check(&token::BinOp(token::Or)) && self.token != token::OrOr {
return Ok(first_pat)
}
let lo = first_pat.span;
-
let mut pats = vec![first_pat];
-
- while self.eat(&token::BinOp(token::Or)) {
- pats.push(self.parse_pat_with_range_pat(
- true, expected
- )?);
+ while self.eat_or_separator() {
+ let pat = self.parse_pat(expected)?;
+ self.maybe_recover_unexpected_comma(pat.span, top_level)?;
+ pats.push(pat);
}
-
let or_pattern_span = lo.to(self.prev_span);
- self.sess.gated_spans.or_patterns.borrow_mut().push(or_pattern_span);
+ // Feature gate the or-pattern if instructed:
+ if gate_or {
+ self.sess.gated_spans.or_patterns.borrow_mut().push(or_pattern_span);
+ }
Ok(self.mk_pat(or_pattern_span, PatKind::Or(pats)))
}
+ /// Eat the or-pattern `|` separator.
+ /// If instead a `||` token is encountered, recover and pretend we parsed `|`.
+ fn eat_or_separator(&mut self) -> bool {
+ match self.token.kind {
+ token::OrOr => {
+ // Found `||`; Recover and pretend we parsed `|`.
+ self.ban_unexpected_or_or();
+ self.bump();
+ true
+ }
+ _ => self.eat(&token::BinOp(token::Or)),
+ }
+ }
+
+ /// We have parsed `||` instead of `|`. Error and suggest `|` instead.
+ fn ban_unexpected_or_or(&mut self) {
+ self.struct_span_err(self.token.span, "unexpected token `||` after pattern")
+ .span_suggestion(
+ self.token.span,
+ "use a single `|` to specify multiple patterns",
+ "|".to_owned(),
+ Applicability::MachineApplicable
+ )
+ .emit();
+ }
+
+ /// Some special error handling for the "top-level" patterns in a match arm,
+ /// `for` loop, `let`, &c. (in contrast to subpatterns within such).
+ fn maybe_recover_unexpected_comma(&mut self, lo: Span, top_level: bool) -> PResult<'a, ()> {
+ if !top_level || self.token != token::Comma {
+ return Ok(());
+ }
+
+ // An unexpected comma after a top-level pattern is a clue that the
+ // user (perhaps more accustomed to some other language) forgot the
+ // parentheses in what should have been a tuple pattern; return a
+ // suggestion-enhanced error here rather than choking on the comma later.
+ let comma_span = self.token.span;
+ self.bump();
+ if let Err(mut err) = self.skip_pat_list() {
+ // We didn't expect this to work anyway; we just wanted to advance to the
+ // end of the comma-sequence so we know the span to suggest parenthesizing.
+ err.cancel();
+ }
+ let seq_span = lo.to(self.prev_span);
+ let mut err = self.struct_span_err(comma_span, "unexpected `,` in pattern");
+ if let Ok(seq_snippet) = self.span_to_snippet(seq_span) {
+ err.span_suggestion(
+ seq_span,
+ "try adding parentheses to match on a tuple..",
+ format!("({})", seq_snippet),
+ Applicability::MachineApplicable
+ )
+ .span_suggestion(
+ seq_span,
+ "..or a vertical bar to match on multiple alternatives",
+ format!("{}", seq_snippet.replace(",", " |")),
+ Applicability::MachineApplicable
+ );
+ }
+ Err(err)
+ }
+
+ /// Parse and throw away a parentesized comma separated
+ /// sequence of patterns until `)` is reached.
+ fn skip_pat_list(&mut self) -> PResult<'a, ()> {
+ while !self.check(&token::CloseDelim(token::Paren)) {
+ self.parse_pat(None)?;
+ if !self.eat(&token::Comma) {
+ return Ok(())
+ }
+ }
+ Ok(())
+ }
+
/// Parses a pattern, with a setting whether modern range patterns (e.g., `a..=b`, `a..b` are
/// allowed).
fn parse_pat_with_range_pat(
&mut self,
allow_range_pat: bool,
- expected: Option<&'static str>,
+ expected: Expected,
) -> PResult<'a, P<Pat>> {
maybe_recover_from_interpolated_ty_qpath!(self, true);
maybe_whole!(self, NtPat, |x| x);
token::OpenDelim(token::Paren) => self.parse_pat_tuple_or_parens()?,
token::OpenDelim(token::Bracket) => {
// Parse `[pat, pat,...]` as a slice pattern.
- PatKind::Slice(self.parse_delim_comma_seq(token::Bracket, |p| p.parse_pat(None))?.0)
+ let (pats, _) = self.parse_delim_comma_seq(
+ token::Bracket,
+ |p| p.parse_pat_with_or(None, true, false),
+ )?;
+ PatKind::Slice(pats)
}
token::DotDot => {
self.bump();
}
/// Parse `&pat` / `&mut pat`.
- fn parse_pat_deref(&mut self, expected: Option<&'static str>) -> PResult<'a, PatKind> {
+ fn parse_pat_deref(&mut self, expected: Expected) -> PResult<'a, PatKind> {
self.expect_and()?;
let mutbl = self.parse_mutability();
/// Parse a tuple or parenthesis pattern.
fn parse_pat_tuple_or_parens(&mut self) -> PResult<'a, PatKind> {
let (fields, trailing_comma) = self.parse_paren_comma_seq(|p| {
- p.parse_pat_with_or(None)
+ p.parse_pat_with_or(None, true, false)
})?;
// Here, `(pat,)` is a tuple pattern.
fn fatal_unexpected_non_pat(
&mut self,
mut err: DiagnosticBuilder<'a>,
- expected: Option<&'static str>,
+ expected: Expected,
) -> PResult<'a, P<Pat>> {
self.cancel(&mut err);
err.span_label(self.token.span, msg);
return Err(err);
}
- let (fields, _) = self.parse_paren_comma_seq(|p| p.parse_pat_with_or(None))?;
+ let (fields, _) = self.parse_paren_comma_seq(|p| p.parse_pat_with_or(None, true, false))?;
Ok(PatKind::TupleStruct(path, fields))
}
// Parsing a pattern of the form "fieldname: pat"
let fieldname = self.parse_field_name()?;
self.bump();
- let pat = self.parse_pat_with_or(None)?;
+ let pat = self.parse_pat_with_or(None, true, false)?;
hi = pat.span;
(pat, fieldname, false)
} else {
projects / rust.git / blobdiff