Try to recover from unmatched delimiters in the parser

src/librustc_metadata/cstore_impl.rs

@@ -465,7 +465,7 @@ impl cstore::CStore {
 
         let source_file = sess.parse_sess.source_map().new_source_file(source_name, def.body);
         let local_span = Span::new(source_file.start_pos, source_file.end_pos, NO_EXPANSION);
-        let body = source_file_to_stream(&sess.parse_sess, source_file, None);
+        let body = source_file_to_stream(&sess.parse_sess, source_file, None).0;
 
         // Mark the attrs as used
         let attrs = data.get_item_attrs(id.index, sess);

src/libsyntax/parse/lexer/mod.rs

@@ -66,6 +66,7 @@ pub struct StringReader<'a> {
     /// The raw source span which *does not* take `override_span` into account
     span_src_raw: Span,
     open_braces: Vec<(token::DelimToken, Span)>,
+    crate unmatched_braces: Vec<(token::DelimToken, Span)>,
     /// The type and spans for all braces
     ///
     /// Used only for error recovery when arriving to EOF with mismatched braces.
@@ -221,6 +222,7 @@ impl<'a> StringReader<'a> {
             span_src_raw: syntax_pos::DUMMY_SP,
             open_braces: Vec::new(),
             matching_delim_spans: Vec::new(),
+            unmatched_braces: Vec::new(),
             override_span,
             last_unclosed_found_span: None,
         }

src/libsyntax/parse/lexer/tokentrees.rs

@@ -49,8 +49,9 @@ impl<'a> StringReader<'a> {
             token::Eof => {
                 let msg = "this file contains an un-closed delimiter";
                 let mut err = self.sess.span_diagnostic.struct_span_err(self.span, msg);
-                for &(_, sp) in &self.open_braces {
+                for &(tok, sp) in &self.open_braces {
                     err.span_label(sp, "un-closed delimiter");
+                    self.unmatched_braces.push((tok, sp));
                 }
 
                 if let Some((delim, _)) = self.open_braces.last() {
@@ -134,7 +135,7 @@ impl<'a> StringReader<'a> {
                             }
                             err.emit();
                         }
-                        self.open_braces.pop().unwrap();
+                        self.unmatched_braces.push(self.open_braces.pop().unwrap());
 
                         // If the incorrect delimiter matches an earlier opening
                         // delimiter, then don't consume it (it can be used to

src/libsyntax/parse/mod.rs

@@ -168,10 +168,13 @@ crate fn parse_stmt_from_source_str(name: FileName, source: String, sess: &Parse
     new_parser_from_source_str(sess, name, source).parse_stmt()
 }
 
-pub fn parse_stream_from_source_str(name: FileName, source: String, sess: &ParseSess,
-                                    override_span: Option<Span>)
-                                    -> TokenStream {
-    source_file_to_stream(sess, sess.source_map().new_source_file(name, source), override_span)
+pub fn parse_stream_from_source_str(
+    name: FileName,
+    source: String,
+    sess: &ParseSess,
+    override_span: Option<Span>,
+) -> TokenStream {
+    source_file_to_stream(sess, sess.source_map().new_source_file(name, source), override_span).0
 }
 
 // Create a new parser from a source string
@@ -191,26 +194,28 @@ pub fn new_parser_from_file<'a>(sess: &'a ParseSess, path: &Path) -> Parser<'a>
 /// Given a session, a crate config, a path, and a span, add
 /// the file at the given path to the source_map, and return a parser.
 /// On an error, use the given span as the source of the problem.
-crate fn new_sub_parser_from_file<'a>(sess: &'a ParseSess,
-                                    path: &Path,
-                                    directory_ownership: DirectoryOwnership,
-                                    module_name: Option<String>,
-                                    sp: Span) -> Parser<'a> {
+crate fn new_sub_parser_from_file<'a>(
+    sess: &'a ParseSess,
+    path: &Path,
+    directory_ownership: DirectoryOwnership,
+    module_name: Option<String>,
+    sp: Span,
+) -> Parser<'a> {
     let mut p = source_file_to_parser(sess, file_to_source_file(sess, path, Some(sp)));
     p.directory.ownership = directory_ownership;
     p.root_module_name = module_name;
     p
 }
 
 /// Given a source_file and config, return a parser
-fn source_file_to_parser(sess: & ParseSess, source_file: Lrc<SourceFile>) -> Parser {
+fn source_file_to_parser(sess: &ParseSess, source_file: Lrc<SourceFile>) -> Parser {
     let end_pos = source_file.end_pos;
-    let mut parser = stream_to_parser(sess, source_file_to_stream(sess, source_file, None));
-
+    let (tts, open_braces) = source_file_to_stream(sess, source_file, None);
+    let mut parser = stream_to_parser(sess, tts);
+    parser.open_braces = open_braces;
     if parser.token == token::Eof && parser.span.is_dummy() {
         parser.span = Span::new(end_pos, end_pos, parser.span.ctxt());
     }
-
     parser
 }
 
@@ -240,12 +245,15 @@ fn file_to_source_file(sess: &ParseSess, path: &Path, spanopt: Option<Span>)
 }
 
 /// Given a source_file, produce a sequence of token-trees
-pub fn source_file_to_stream(sess: &ParseSess,
-                             source_file: Lrc<SourceFile>,
-                             override_span: Option<Span>) -> TokenStream {
+pub fn source_file_to_stream(
+    sess: &ParseSess,
+    source_file: Lrc<SourceFile>,
+    override_span: Option<Span>,
+) -> (TokenStream, Vec<(token::DelimToken, Span)>) {
     let mut srdr = lexer::StringReader::new(sess, source_file, override_span);
     srdr.real_token();
-    panictry!(srdr.parse_all_token_trees())
+    let tt = panictry!(srdr.parse_all_token_trees());
+    (tt, srdr.unmatched_braces)
 }
 
 /// Given stream and the `ParseSess`, produce a parser

src/libsyntax/parse/parser.rs

@@ -250,6 +250,8 @@ pub struct Parser<'a> {
     desugar_doc_comments: bool,
     /// Whether we should configure out of line modules as we parse.
     pub cfg_mods: bool,
+    /// Unmatched open delimiters, used for parse recovery when multiple tokens could be valid.
+    crate open_braces: Vec<(token::DelimToken, Span)>,
 }
 
 
@@ -569,6 +571,7 @@ impl<'a> Parser<'a> {
             },
             desugar_doc_comments,
             cfg_mods: true,
+            open_braces: Vec::new(),
         };
 
         let tok = parser.next_tok();
@@ -635,6 +638,55 @@ impl<'a> Parser<'a> {
         }
     }
 
+    fn recover_closing_delimiter(
+        &mut self,
+        tokens: &[token::Token],
+        mut err: DiagnosticBuilder<'a>,
+    ) -> PResult<'a, ()> {
+        let mut pos = None;
+        let mut tokens: Vec<token::Token> = tokens.iter().map(|t| (*t).clone()).collect();
+        tokens.extend(self.expected_tokens.iter().filter_map(|t| match t {
+            TokenType::Token(t) => Some((*t).clone()),
+            _ => None,
+        }));
+        for (i, (delim, span)) in self.open_braces.iter().enumerate() {
+            if tokens.contains(&token::CloseDelim(*delim)) && self.span > *span {
+                pos = Some(i);
+                // do not break, we want to use the last one that would apply
+            }
+        }
+        match pos {
+            Some(pos) => {
+                // Recover and assume that the detected unclosed delimiter was meant for
+                // this location. Emit the diagnostic and act as if the delimiter was
+                // present for the parser's sake.
+
+                // Don't attempt to recover from this unclosed delimiter more than once.
+                let (delim, open_sp) = self.open_braces.remove(pos);
+                let delim = TokenType::Token(token::CloseDelim(delim));
+
+                // We want to suggest the inclusion of the closing delimiter where it makes
+                // the most sense, which is immediately after the last token:
+                //
+                //  {foo(bar {}}
+                //      -   -  ^ expected one of `)`, <...>
+                //      |   |
+                //      |   help: ...missing `)` might belong here
+                //      you might have meant to close this...
+                err.span_label(open_sp, "if you meant to close this...");
+                err.span_suggestion_short_with_applicability(
+                    self.sess.source_map().next_point(self.prev_span),
+                    &format!("...the missing {} may belong here", delim.to_string()),
+                    delim.to_string(),
+                    Applicability::MaybeIncorrect,
+                );
+                err.emit();
+                Ok(())
+            }
+            _ => Err(err),
+        }
+    }
+
     /// Expect and consume the token t. Signal an error if
     /// the next token is not t.
     pub fn expect(&mut self, t: &token::Token) -> PResult<'a,  ()> {
@@ -668,7 +720,7 @@ impl<'a> Parser<'a> {
                         err.span_label(self.span, "unexpected token");
                     }
                 }
-                Err(err)
+                self.recover_closing_delimiter(&[t.clone()], err)
             }
         } else {
             self.expect_one_of(slice::from_ref(t), &[])
@@ -761,7 +813,7 @@ impl<'a> Parser<'a> {
                     err.span_label(self.span, "unexpected token");
                 }
             }
-            Err(err)
+            self.recover_closing_delimiter(edible, err)
         }
     }
 
@@ -1075,11 +1127,12 @@ impl<'a> Parser<'a> {
     /// Parse a sequence, not including the closing delimiter. The function
     /// f must consume tokens until reaching the next separator or
     /// closing bracket.
-    pub fn parse_seq_to_before_end<T, F>(&mut self,
-                                         ket: &token::Token,
-                                         sep: SeqSep,
-                                         f: F)
-                                         -> PResult<'a, Vec<T>>
+    pub fn parse_seq_to_before_end<T, F>(
+        &mut self,
+        ket: &token::Token,
+        sep: SeqSep,
+        f: F,
+    ) -> PResult<'a, Vec<T>>
         where F: FnMut(&mut Parser<'a>) -> PResult<'a, T>
     {
         self.parse_seq_to_before_tokens(&[ket], sep, TokenExpectType::Expect, f)
@@ -1124,8 +1177,12 @@ impl<'a> Parser<'a> {
                                 v.push(t);
                                 continue;
                             },
-                            Err(mut e) => {
-                                e.cancel();
+                            Err(mut err) => {
+                                err.cancel();
+                                let kets: Vec<token::Token> = kets.iter()
+                                    .map(|t| (*t).clone())
+                                    .collect();
+                                let _ = self.recover_closing_delimiter(&kets[..], e);
                                 break;
                             }
                         }
@@ -1141,7 +1198,13 @@ impl<'a> Parser<'a> {
                 break;
             }
 
-            let t = f(self)?;
+            let t = match f(self) {
+                Ok(t) => t,
+                Err(e) => {
+                    let kets: Vec<token::Token> = kets.iter().map(|t| (*t).clone()).collect();
+                    return self.recover_closing_delimiter(&kets[..], e).map(|_| v);
+                }
+            };
             v.push(t);
         }
 
@@ -1151,12 +1214,13 @@ impl<'a> Parser<'a> {
     /// Parse a sequence, including the closing delimiter. The function
     /// f must consume tokens until reaching the next separator or
     /// closing bracket.
-    fn parse_unspanned_seq<T, F>(&mut self,
-                                     bra: &token::Token,
-                                     ket: &token::Token,
-                                     sep: SeqSep,
-                                     f: F)
-                                     -> PResult<'a, Vec<T>> where
+    fn parse_unspanned_seq<T, F>(
+        &mut self,
+        bra: &token::Token,
+        ket: &token::Token,
+        sep: SeqSep,
+        f: F,
+    ) -> PResult<'a, Vec<T>> where
         F: FnMut(&mut Parser<'a>) -> PResult<'a, T>,
     {
         self.expect(bra)?;

src/test/ui/parser-recovery-3.rs

@@ -0,0 +1,24 @@
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+struct A;
+
+impl A {
+    fn banana(&mut self) {
+        fn peach(this: &Self, foo: usize {
+        //~^ ERROR expected one of
+        //~| ERROR expected pattern
+        }
+    }
+    //~^ ERROR expected one of
+    //~| ERROR incorrect close delimiter
+}
+
+fn main() {}

src/test/ui/parser-recovery-3.stderr

@@ -0,0 +1,34 @@
+error: incorrect close delimiter: `}`
+  --> $DIR/parser-recovery-3.rs:19:5
+   |
+LL |     fn banana(&mut self) {
+   |                          - close delimiter possibly meant for this
+LL |         fn peach(this: &Self, foo: usize {
+   |                 - un-closed delimiter
+...
+LL |     }
+   |     ^ incorrect close delimiter
+
+error: expected one of `!`, `(`, `)`, `+`, `,`, `::`, or `<`, found `{`
+  --> $DIR/parser-recovery-3.rs:15:42
+   |
+LL |         fn peach(this: &Self, foo: usize {
+   |                 -                       -^ expected one of 7 possible tokens here
+   |                 |                       |
+   |                 |                       help: ...the missing `)` may belong here
+   |                 if you meant to close this...
+
+error: expected pattern, found `{`
+  --> $DIR/parser-recovery-3.rs:15:42
+   |
+LL |         fn peach(this: &Self, foo: usize {
+   |                                          ^ expected pattern
+
+error: expected one of `->`, `where`, or `{`, found `}`
+  --> $DIR/parser-recovery-3.rs:19:5
+   |
+LL |     }
+   |     ^ expected one of `->`, `where`, or `{` here
+
+error: aborting due to 4 previous errors
+

src/test/ui/parser-recovery-4.rs

@@ -0,0 +1,21 @@
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn foo(_: usize) {}
+fn bar() {}
+
+fn main() {
+    let x = 1;
+    foo(x
+    bar()
+    //~^ ERROR expected one of
+    //~^^^ ERROR this function takes 1 parameter but 2 parameters were supplied
+}
+//~^ ERROR incorrect close delimiter