use fields in autotupling parse recovery

We introduce a new `PartialPResult`, which is like `PResult`, except
instead of the `Err` value being just a `DiagnosticBuilder`, it's a
tuple whose first element is of the `Ok` type and whose second element
is the diagnostic-builder: this provides a way to return to callers any
useful parsing work we did before hitting the error (at the cost of
having to sprinkle some awkward `.map_err`s around to convert between
`PResult` and `PartialPResult`).

`PartialPResult` is then used for more thorough recovery when a user
omits the parens from what we presume ought to have been a tuple
pattern: after emitting an error for the erroneous pattern, we can
continue working with the destructured fields as if the user had
correctly written a tuple, potentially catching more errors in
subsequent code without the user needing to recompile.

src/libsyntax/parse/mod.rs

@@ -30,6 +30,11 @@ use std::str;
 
 pub type PResult<'a, T> = Result<T, DiagnosticBuilder<'a>>;
 
+/// Like `PResult`, but the `Err` value is a tuple whose first value is a
+/// "partial result" (of some useful work we did before hitting the error), and
+/// whose second value is the error.
+pub type PartialPResult<'a, T> = Result<T, (T, DiagnosticBuilder<'a>)>;
+
 #[macro_use]
 pub mod parser;
 

src/libsyntax/parse/parser.rs

@@ -53,7 +53,7 @@ use parse::{new_sub_parser_from_file, ParseSess, Directory, DirectoryOwnership};
 use util::parser::{AssocOp, Fixity};
 use print::pprust;
 use ptr::P;
-use parse::PResult;
+use parse::{PResult, PartialPResult};
 use tokenstream::{self, Delimited, ThinTokenStream, TokenTree, TokenStream};
 use symbol::{Symbol, keywords};
 use util::ThinVec;
@@ -3485,7 +3485,7 @@ impl<'a> Parser<'a> {
     }
 
     fn parse_pat_tuple_elements(&mut self, unary_needs_comma: bool)
-                                -> PResult<'a, (Vec<P<Pat>>, Option<usize>)> {
+                                -> PartialPResult<'a, (Vec<P<Pat>>, Option<usize>)> {
         let mut fields = vec![];
         let mut ddpos = None;
 
@@ -3494,19 +3494,24 @@ impl<'a> Parser<'a> {
                 ddpos = Some(fields.len());
                 if self.eat(&token::Comma) {
                     // `..` needs to be followed by `)` or `, pat`, `..,)` is disallowed.
-                    fields.push(self.parse_pat()?);
+                    let field = self.parse_pat()
+                        .map_err(|err| ((fields.clone(), ddpos), err))?;
+                    fields.push(field);
                 }
             } else if ddpos.is_some() && self.eat(&token::DotDot) {
                 // Emit a friendly error, ignore `..` and continue parsing
                 self.span_err(self.prev_span, "`..` can only be used once per \
                                                tuple or tuple struct pattern");
             } else {
-                fields.push(self.parse_pat()?);
+                let field = self.parse_pat()
+                    .map_err(|err| ((fields.clone(), ddpos), err))?;
+                fields.push(field);
             }
 
             if !self.check(&token::CloseDelim(token::Paren)) ||
                     (unary_needs_comma && fields.len() == 1 && ddpos.is_none()) {
-                self.expect(&token::Comma)?;
+                self.expect(&token::Comma)
+                    .map_err(|err| ((fields.clone(), ddpos), err))?;
             }
         }
 
@@ -3690,11 +3695,11 @@ impl<'a> Parser<'a> {
         }))
     }
 
-    /// A wrapper around `parse_pat` with some special error handling for the
-    /// "top-level" patterns in a match arm, `for` loop, `let`, &c. (in contast
-    /// to subpatterns within such).
+    /// A wrapper around `parse_pat` with some special error handling and
+    /// recovery for the "top-level" patterns in a match arm, `for` loop,
+    /// `let`, &c. (in contast to subpatterns within such).
     pub fn parse_top_level_pat(&mut self) -> PResult<'a, P<Pat>> {
-        let pat = self.parse_pat()?;
+        let mut pat = self.parse_pat()?;
         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
@@ -3703,12 +3708,21 @@ impl<'a> Parser<'a> {
             // later.
             let comma_span = self.span;
             self.bump();
-            if let Err(mut err) = self.parse_pat_tuple_elements(false) {
-                // 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 mut fields = vec![pat.clone()];
+            let (rest_fields, ddpos) = match self.parse_pat_tuple_elements(false) {
+                Ok(fields_ddpos) => fields_ddpos,
+                Err((fields_ddpos, mut err)) => {
+                    // We didn't really expect this to work anyway; we want the
+                    // partial result (so that post-recovery code knows about
+                    // any bindings) and to advance to the end of the
+                    // comma-sequence (so we know the span to suggest
+                    // parenthesizing), but we'll emit our own error in just a
+                    // moment
+                    err.cancel();
+                    fields_ddpos
+                }
+            };
+            fields.extend(rest_fields);
             let seq_span = pat.span.to(self.prev_span);
             let mut err = self.struct_span_err(comma_span,
                                                "unexpected `,` in pattern");
@@ -3717,6 +3731,11 @@ impl<'a> Parser<'a> {
                                     format!("({})", seq_snippet));
             }
             err.emit();
+            // Now that we've emitted our own error, the rest of the parser
+            // can pretend this was actually a tuple
+            pat = P(Pat { node: PatKind::Tuple(fields, ddpos),
+                          span: seq_span,
+                          id: ast::DUMMY_NODE_ID });
         }
         Ok(pat)
     }
@@ -3746,7 +3765,8 @@ impl<'a> Parser<'a> {
             token::OpenDelim(token::Paren) => {
                 // Parse (pat,pat,pat,...) as tuple pattern
                 self.bump();
-                let (fields, ddpos) = self.parse_pat_tuple_elements(true)?;
+                let (fields, ddpos) = self.parse_pat_tuple_elements(true)
+                    .map_err(|(_partial, err)| err)?;
                 self.expect(&token::CloseDelim(token::Paren))?;
                 pat = PatKind::Tuple(fields, ddpos);
             }
@@ -3839,7 +3859,8 @@ impl<'a> Parser<'a> {
                         }
                         // Parse tuple struct or enum pattern
                         self.bump();
-                        let (fields, ddpos) = self.parse_pat_tuple_elements(false)?;
+                        let (fields, ddpos) = self.parse_pat_tuple_elements(false)
+                            .map_err(|(_partial, err)| err)?;
                         self.expect(&token::CloseDelim(token::Paren))?;
                         pat = PatKind::TupleStruct(path, fields, ddpos)
                     }

src/test/ui/did_you_mean/issue-48492-tuple-destructure-missing-parens.rs

@@ -42,10 +42,15 @@ struct Genome {
     allosomes: (Allosome, Allosome)
 }
 
+fn three_slice_to_tuple<T>(slice: &[T]) -> (T, T, T) {
+    (slice[0], slice[1], slice[2])
+}
+
 fn find_start_codon(strand: &[Nucleotide]) -> Option<usize> {
     let mut reading_frame = strand.windows(3);
-    while let b1, b2, b3 = reading_frame.next().expect("there should be a start codon") {
-        //~^ ERROR unexpected `,` in pattern
+    while let b1, b2, b3 = three_slice_to_tuple(reading_frame.next()
+    //~^ ERROR unexpected `,` in pattern
+                                                .expect("there should be a start codon")) {
         // ...
     }
     None
@@ -54,11 +59,9 @@ fn find_start_codon(strand: &[Nucleotide]) -> Option<usize> {
 fn find_thr(strand: &[Nucleotide]) -> Option<usize> {
     let mut reading_frame = strand.windows(3);
     let mut i = 0;
-    if let b1, b2, b3 = reading_frame.next().unwrap() {
+    if let b1, b2, b3 = three_slice_to_tuple(reading_frame.next().unwrap()) {
         //~^ ERROR unexpected `,` in pattern
         match (b1, b2, b3) {
-            //~^ ERROR cannot find value `b2` in this scope
-            //~| ERROR cannot find value `b3` in this scope
             Nucleotide::Adenine, Nucleotide::Cytosine, _ => {
                 //~^ ERROR unexpected `,` in pattern
                 return Some(i);

src/test/ui/did_you_mean/issue-48492-tuple-destructure-missing-parens.stderr

@@ -1,50 +1,38 @@
 error: unexpected `,` in pattern
-  --> $DIR/issue-48492-tuple-destructure-missing-parens.rs:47:17
+  --> $DIR/issue-48492-tuple-destructure-missing-parens.rs:51:17
    |
-47 |     while let b1, b2, b3 = reading_frame.next().expect("there should be a start codon") {
+51 |     while let b1, b2, b3 = three_slice_to_tuple(reading_frame.next()
    |               --^------- help: try adding parentheses: `(b1, b2, b3)`
 
 error: unexpected `,` in pattern
-  --> $DIR/issue-48492-tuple-destructure-missing-parens.rs:57:14
+  --> $DIR/issue-48492-tuple-destructure-missing-parens.rs:62:14
    |
-57 |     if let b1, b2, b3 = reading_frame.next().unwrap() {
+62 |     if let b1, b2, b3 = three_slice_to_tuple(reading_frame.next().unwrap()) {
    |            --^------- help: try adding parentheses: `(b1, b2, b3)`
 
 error: unexpected `,` in pattern
-  --> $DIR/issue-48492-tuple-destructure-missing-parens.rs:62:32
+  --> $DIR/issue-48492-tuple-destructure-missing-parens.rs:65:32
    |
-62 |             Nucleotide::Adenine, Nucleotide::Cytosine, _ => {
+65 |             Nucleotide::Adenine, Nucleotide::Cytosine, _ => {
    |             -------------------^------------------------ help: try adding parentheses: `(Nucleotide::Adenine, Nucleotide::Cytosine, _)`
 
 error: unexpected `,` in pattern
-  --> $DIR/issue-48492-tuple-destructure-missing-parens.rs:74:10
+  --> $DIR/issue-48492-tuple-destructure-missing-parens.rs:77:10
    |
-74 |     for x, _barr_body in women.iter().map(|woman| woman.allosomes.clone()) {
+77 |     for x, _barr_body in women.iter().map(|woman| woman.allosomes.clone()) {
    |         -^----------- help: try adding parentheses: `(x, _barr_body)`
 
 error: unexpected `,` in pattern
-  --> $DIR/issue-48492-tuple-destructure-missing-parens.rs:78:10
+  --> $DIR/issue-48492-tuple-destructure-missing-parens.rs:81:10
    |
-78 |     for x, y @ Allosome::Y(_) in men.iter().map(|man| man.allosomes.clone()) {
+81 |     for x, y @ Allosome::Y(_) in men.iter().map(|man| man.allosomes.clone()) {
    |         -^------------------- help: try adding parentheses: `(x, y @ Allosome::Y(_))`
 
 error: unexpected `,` in pattern
-  --> $DIR/issue-48492-tuple-destructure-missing-parens.rs:86:14
+  --> $DIR/issue-48492-tuple-destructure-missing-parens.rs:89:14
    |
-86 |     let women, men: (Vec<Genome>, Vec<Genome>) = genomes.iter().cloned()
+89 |     let women, men: (Vec<Genome>, Vec<Genome>) = genomes.iter().cloned()
    |         -----^---- help: try adding parentheses: `(women, men)`
 
-error[E0425]: cannot find value `b2` in this scope
-  --> $DIR/issue-48492-tuple-destructure-missing-parens.rs:59:20
-   |
-59 |         match (b1, b2, b3) {
-   |                    ^^ did you mean `b1`?
-
-error[E0425]: cannot find value `b3` in this scope
-  --> $DIR/issue-48492-tuple-destructure-missing-parens.rs:59:24
-   |
-59 |         match (b1, b2, b3) {
-   |                        ^^ did you mean `b1`?
-
-error: aborting due to 8 previous errors
+error: aborting due to 6 previous errors