Put in -Z continue_parse_after_error

This works by adding a method, `fn abort_if_no_parse_recovery`, to the
diagnostic handler in `syntax::errors`, and calling it after each
error is emitted in the parser.

(We might consider adding a debugflag to do such aborts in other
places where we are currently attempting recovery, such as resolve,
but I think the parser is the really important case to handle in the
face of #31994 and the parser bugs of varying degrees that were
injected by parse error recovery.)

Author: pnkfelix

src/librustc/session/config.rs

@@ -138,6 +138,7 @@ pub struct Options {
     pub no_trans: bool,
     pub error_format: ErrorOutputType,
     pub treat_err_as_bug: bool,
+    pub continue_parse_after_error: bool,
     pub mir_opt_level: usize,
 
     /// if true, build up the dep-graph
@@ -259,6 +260,7 @@ pub fn basic_options() -> Options {
         parse_only: false,
         no_trans: false,
         treat_err_as_bug: false,
+        continue_parse_after_error: false,
         mir_opt_level: 1,
         build_dep_graph: false,
         dump_dep_graph: false,
@@ -633,6 +635,8 @@ options! {DebuggingOptions, DebuggingSetter, basic_debugging_options,
           "run all passes except translation; no output"),
     treat_err_as_bug: bool = (false, parse_bool,
           "treat all errors that occur as bugs"),
+    continue_parse_after_error: bool = (false, parse_bool,
+          "attempt to recover from parse errors (experimental)"),
     incr_comp: bool = (false, parse_bool,
           "enable incremental compilation (experimental)"),
     dump_dep_graph: bool = (false, parse_bool,
@@ -1045,6 +1049,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options {
     let parse_only = debugging_opts.parse_only;
     let no_trans = debugging_opts.no_trans;
     let treat_err_as_bug = debugging_opts.treat_err_as_bug;
+    let continue_parse_after_error = debugging_opts.continue_parse_after_error;
     let mir_opt_level = debugging_opts.mir_opt_level.unwrap_or(1);
     let incremental_compilation = debugging_opts.incr_comp;
     let dump_dep_graph = debugging_opts.dump_dep_graph;
@@ -1228,6 +1233,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options {
         parse_only: parse_only,
         no_trans: no_trans,
         treat_err_as_bug: treat_err_as_bug,
+        continue_parse_after_error: continue_parse_after_error,
         mir_opt_level: mir_opt_level,
         build_dep_graph: incremental_compilation || dump_dep_graph,
         dump_dep_graph: dump_dep_graph,

src/librustc/session/mod.rs

@@ -414,6 +414,7 @@ pub fn build_session(sopts: config::Options,
         .last()
         .unwrap_or(true);
     let treat_err_as_bug = sopts.treat_err_as_bug;
+    let continue_parse_after_error = sopts.continue_parse_after_error;
 
     let codemap = Rc::new(codemap::CodeMap::new());
     let emitter: Box<Emitter> = match sopts.error_format {
@@ -428,6 +429,7 @@ pub fn build_session(sopts: config::Options,
     let diagnostic_handler =
         errors::Handler::with_emitter(can_print_warnings,
                                       treat_err_as_bug,
+                                      continue_parse_after_error,
                                       emitter);
 
     build_session_(sopts, local_crate_source_file, diagnostic_handler, codemap, cstore)

src/librustc_trans/back/write.rs

@@ -908,7 +908,7 @@ fn run_work_multithreaded(sess: &Session,
         futures.push(rx);
 
         thread::Builder::new().name(format!("codegen-{}", i)).spawn(move || {
-            let diag_handler = Handler::with_emitter(true, false, box diag_emitter);
+            let diag_handler = Handler::with_emitter(true, false, false, box diag_emitter);
 
             // Must construct cgcx inside the proc because it has non-Send
             // fields.

src/librustdoc/core.rs

@@ -123,6 +123,7 @@ pub fn run_core(search_paths: SearchPaths, cfgs: Vec<String>, externs: Externs,
                                                                None,
                                                                true,
                                                                false,
+                                                               false,
                                                                codemap.clone());
 
     let cstore = Rc::new(CStore::new(token::get_ident_interner()));

src/librustdoc/test.rs

@@ -77,6 +77,7 @@ pub fn run(input: &str,
                                                                None,
                                                                true,
                                                                false,
+                                                               false,
                                                                codemap.clone());
 
     let cstore = Rc::new(CStore::new(token::get_ident_interner()));
@@ -235,7 +236,7 @@ fn runtest(test: &str, cratename: &str, cfgs: Vec<String>, libs: SearchPaths,
     let _bomb = Bomb(data, old.unwrap_or(box io::stdout()));
 
     // Compile the code
-    let diagnostic_handler = errors::Handler::with_emitter(true, false, box emitter);
+    let diagnostic_handler = errors::Handler::with_emitter(true, false, false, box emitter);
 
     let cstore = Rc::new(CStore::new(token::get_ident_interner()));
     let sess = session::build_session_(sessopts,

src/libsyntax/errors/mod.rs

@@ -370,6 +370,7 @@ pub struct Handler {
     emit: RefCell<Box<Emitter>>,
     pub can_emit_warnings: bool,
     treat_err_as_bug: bool,
+    continue_parse_after_err: bool,
     delayed_span_bug: RefCell<Option<(MultiSpan, String)>>,
 }
 
@@ -378,20 +379,26 @@ impl Handler {
                             registry: Option<diagnostics::registry::Registry>,
                             can_emit_warnings: bool,
                             treat_err_as_bug: bool,
+                            continue_parse_after_err: bool,
                             cm: Rc<codemap::CodeMap>)
                             -> Handler {
         let emitter = Box::new(EmitterWriter::stderr(color_config, registry, cm));
-        Handler::with_emitter(can_emit_warnings, treat_err_as_bug, emitter)
+        Handler::with_emitter(can_emit_warnings,
+                              treat_err_as_bug,
+                              continue_parse_after_err,
+                              emitter)
     }
 
     pub fn with_emitter(can_emit_warnings: bool,
                         treat_err_as_bug: bool,
+                        continue_parse_after_err: bool,
                         e: Box<Emitter>) -> Handler {
         Handler {
             err_count: Cell::new(0),
             emit: RefCell::new(e),
             can_emit_warnings: can_emit_warnings,
             treat_err_as_bug: treat_err_as_bug,
+            continue_parse_after_err: continue_parse_after_err,
             delayed_span_bug: RefCell::new(None),
         }
     }
@@ -572,7 +579,13 @@ impl Handler {
         self.bug(&format!("unimplemented {}", msg));
     }
 
-    pub fn bump_err_count(&self) {
+    pub fn abort_if_no_parse_recovery(&self) {
+        if !self.continue_parse_after_err {
+            self.abort_if_errors();
+        }
+    }
+
+    fn bump_err_count(&self) {
         self.err_count.set(self.err_count.get() + 1);
     }
 

src/libsyntax/parse/mod.rs

@@ -49,7 +49,7 @@ pub struct ParseSess {
 impl ParseSess {
     pub fn new() -> ParseSess {
         let cm = Rc::new(CodeMap::new());
-        let handler = Handler::with_tty_emitter(ColorConfig::Auto, None, true, false, cm.clone());
+        let handler = Handler::with_tty_emitter(ColorConfig::Auto, None, true, false, true, cm.clone());
         ParseSess::with_span_handler(handler, cm)
     }
 

src/libsyntax/parse/parser.rs

@@ -689,7 +689,8 @@ impl<'a> Parser<'a> {
     pub fn check_reserved_keywords(&mut self) {
         if self.token.is_reserved_keyword() {
             let token_str = self.this_token_to_string();
-            self.fatal(&format!("`{}` is a reserved keyword", token_str)).emit()
+            self.fatal(&format!("`{}` is a reserved keyword", token_str)).emit();
+            self.sess.span_diagnostic.abort_if_no_parse_recovery();
         }
     }
 
@@ -869,7 +870,7 @@ impl<'a> Parser<'a> {
         self.parse_seq_to_before_tokens(kets,
                                         SeqSep::none(),
                                         |p| p.parse_token_tree(),
-                                        |mut e| e.cancel());
+                                        |_self, mut e| e.cancel());
     }
 
     /// Parse a sequence, including the closing delimiter. The function
@@ -897,7 +898,10 @@ impl<'a> Parser<'a> {
                                          -> Vec<T>
         where F: FnMut(&mut Parser<'a>) -> PResult<'a,  T>,
     {
-        self.parse_seq_to_before_tokens(&[ket], sep, f, |mut e| e.emit())
+        self.parse_seq_to_before_tokens(&[ket], sep, f, |s, mut e| {
+            e.emit();
+            s.sess.span_diagnostic.abort_if_no_parse_recovery();
+        })
     }
 
     // `fe` is an error handler.
@@ -908,7 +912,7 @@ impl<'a> Parser<'a> {
                                             mut fe: Fe)
                                             -> Vec<T>
         where F: FnMut(&mut Parser<'a>) -> PResult<'a,  T>,
-              Fe: FnMut(DiagnosticBuilder)
+              Fe: FnMut(&mut Parser<'a>, DiagnosticBuilder)
     {
         let mut first: bool = true;
         let mut v = vec!();
@@ -919,7 +923,7 @@ impl<'a> Parser<'a> {
                         first = false;
                     } else {
                         if let Err(e) = self.expect(t) {
-                            fe(e);
+                            fe(self, e);
                             break;
                         }
                     }
@@ -933,7 +937,7 @@ impl<'a> Parser<'a> {
             match f(self) {
                 Ok(t) => v.push(t),
                 Err(e) => {
-                    fe(e);
+                    fe(self, e);
                     break;
                 }
             }
@@ -1091,7 +1095,8 @@ impl<'a> Parser<'a> {
         self.sess.span_diagnostic.span_warn(sp, m)
     }
     pub fn span_err(&self, sp: Span, m: &str) {
-        self.sess.span_diagnostic.span_err(sp, m)
+        self.sess.span_diagnostic.span_err(sp, m);
+        self.sess.span_diagnostic.abort_if_no_parse_recovery();
     }
     pub fn span_bug(&self, sp: Span, m: &str) -> ! {
         self.sess.span_diagnostic.span_bug(sp, m)
@@ -2375,6 +2380,7 @@ impl<'a> Parser<'a> {
                                         }
                                         Err(mut e) => {
                                             e.emit();
+                                            self.sess.span_diagnostic.abort_if_no_parse_recovery();
                                             self.recover_stmt();
                                         }
                                     }
@@ -2385,6 +2391,7 @@ impl<'a> Parser<'a> {
                                     Ok(f) => fields.push(f),
                                     Err(mut e) => {
                                         e.emit();
+                                        self.sess.span_diagnostic.abort_if_no_parse_recovery();
                                         self.recover_stmt();
                                         break;
                                     }
@@ -2396,6 +2403,7 @@ impl<'a> Parser<'a> {
                                     Ok(()) => {}
                                     Err(mut e) => {
                                         e.emit();
+                                        self.sess.span_diagnostic.abort_if_no_parse_recovery();
                                         self.recover_stmt();
                                         break;
                                     }
@@ -2704,8 +2712,10 @@ impl<'a> Parser<'a> {
     pub fn check_unknown_macro_variable(&mut self) {
         if self.quote_depth == 0 {
             match self.token {
-                token::SubstNt(name, _) =>
-                    self.fatal(&format!("unknown macro variable `{}`", name)).emit(),
+                token::SubstNt(name, _) => {
+                    self.fatal(&format!("unknown macro variable `{}`", name)).emit();
+                    self.sess.span_diagnostic.abort_if_no_parse_recovery();
+                }
                 _ => {}
             }
         }
@@ -3076,6 +3086,7 @@ impl<'a> Parser<'a> {
                         "use `::<...>` instead of `<...>` if you meant to specify type arguments");
                 }
                 err.emit();
+                self.sess.span_diagnostic.abort_if_no_parse_recovery();
             }
             _ => {}
         }
@@ -3284,6 +3295,7 @@ impl<'a> Parser<'a> {
                 Err(mut e) => {
                     // Recover by skipping to the end of the block.
                     e.emit();
+                    self.sess.span_diagnostic.abort_if_no_parse_recovery();
                     self.recover_stmt();
                     let hi = self.span.hi;
                     if self.token == token::CloseDelim(token::Brace) {
@@ -3652,6 +3664,7 @@ impl<'a> Parser<'a> {
                         self.bump();
                         let (fields, etc) = self.parse_pat_fields().unwrap_or_else(|mut e| {
                             e.emit();
+                            self.sess.span_diagnostic.abort_if_no_parse_recovery();
                             self.recover_stmt();
                             (vec![], false)
                         });
@@ -3868,6 +3881,7 @@ impl<'a> Parser<'a> {
     fn parse_stmt_(&mut self) -> Option<Stmt> {
         self.parse_stmt_without_recovery().unwrap_or_else(|mut e| {
             e.emit();
+            self.sess.span_diagnostic.abort_if_no_parse_recovery();
             self.recover_stmt_(SemiColonMode::Break);
             None
         })
@@ -4139,6 +4153,7 @@ impl<'a> Parser<'a> {
                 self.commit_stmt(&[], &[token::Semi, token::CloseDelim(token::Brace)])
             {
                 e.emit();
+                self.sess.span_diagnostic.abort_if_no_parse_recovery();
                 self.recover_stmt();
             }
         }
@@ -4529,6 +4544,7 @@ impl<'a> Parser<'a> {
                             Ok(arg) => Ok(Some(arg)),
                             Err(mut e) => {
                                 e.emit();
+                                p.sess.span_diagnostic.abort_if_no_parse_recovery();
                                 p.eat_to_tokens(&[&token::Comma, &token::CloseDelim(token::Paren)]);
                                 Ok(None)
                             }
@@ -4917,6 +4933,7 @@ impl<'a> Parser<'a> {
                                                            inside the invocation")
                                      .emit();
                 }
+                self.sess.span_diagnostic.abort_if_no_parse_recovery();
             }
             Visibility::Inherited => (),
         }
@@ -5778,6 +5795,7 @@ impl<'a> Parser<'a> {
                 self.diagnostic().struct_span_err(last_span, "const globals cannot be mutable")
                                  .fileline_help(last_span, "did you mean to declare a static?")
                                  .emit();
+                self.sess.span_diagnostic.abort_if_no_parse_recovery();
             }
             let (ident, item_, extra_attrs) = self.parse_item_const(None)?;
             let last_span = self.last_span;