feat: continue on recovered parse errors in ignore files

Author: calebcartwright

src/formatting.rs

@@ -1,5 +1,6 @@
 // High level formatting functions.
 
+use std::cell::Cell;
 use std::collections::HashMap;
 use std::io::{self, Write};
 use std::panic::{catch_unwind, AssertUnwindSafe};
@@ -27,6 +28,8 @@ mod newline_style;
 pub(crate) type SourceFile = Vec<FileRecord>;
 pub(crate) type FileRecord = (FileName, String);
 
+thread_local!(static CAN_RESET_CRATE_PARSE_ERRORS: Cell<bool> = Cell::new(false));
+
 impl<'b, T: Write + 'b> Session<'b, T> {
     pub(crate) fn format_input_inner(&mut self, input: Input) -> Result<FormatReport, ErrorKind> {
         if !self.config.version_meets_requirement() {
@@ -70,17 +73,16 @@ fn format_project<T: FormatHandler>(
         Ok(set) => set,
         Err(e) => return Err(ErrorKind::InvalidGlobPattern(e)),
     };
-    let is_ignore_match = ignore_path_set.is_match(&main_file);
-    if config.skip_children() && is_ignore_match {
+    if config.skip_children() && ignore_path_set.is_match(&main_file) {
         return Ok(FormatReport::new());
     }
+    let _ = CAN_RESET_CRATE_PARSE_ERRORS.try_with(|r| {
+        r.set(false);
+    });
 
     // Parse the crate.
     let source_map = Rc::new(SourceMap::new(FilePathMapping::empty()));
     let mut parse_session = make_parse_sess(source_map.clone(), config, &ignore_path_set);
-    if is_ignore_match {
-        parse_session.span_diagnostic = Handler::with_emitter(true, None, silent_emitter());
-    }
     let mut report = FormatReport::new();
     let directory_ownership = input.to_directory_ownership();
     let krate = match parse_crate(
@@ -92,13 +94,7 @@ fn format_project<T: FormatHandler>(
     ) {
         Ok(krate) => krate,
         // Surface parse error via Session (errors are merged there from report)
-        Err(ErrorKind::ParseError) => {
-            // https://github.com/rust-lang/rustfmt/issues/3779
-            if is_ignore_match {
-                return Ok(FormatReport::new());
-            }
-            return Ok(report);
-        }
+        Err(ErrorKind::ParseError) => return Ok(report),
         Err(e) => return Err(e),
     };
     timer = timer.done_parsing();
@@ -677,6 +673,19 @@ fn parse_crate(
             if !parse_session.span_diagnostic.has_errors() {
                 return Ok(c);
             }
+            // This scenario occurs when the parser encountered errors
+            // but was still able to recover. If all of the parser errors
+            // occurred in files that are ignored, then reset
+            // the error count and continue.
+            // https://github.com/rust-lang/rustfmt/issues/3779
+            let mut can_reset = false;
+            let _ = CAN_RESET_CRATE_PARSE_ERRORS.try_with(|r| {
+                can_reset = r.get();
+            });
+            if can_reset {
+                parse_session.span_diagnostic.reset_err_count();
+                return Ok(c);
+            }
         }
         Ok(Err(mut diagnostics)) => diagnostics.iter_mut().for_each(DiagnosticBuilder::emit),
         Err(_) => {
@@ -697,6 +706,8 @@ struct SilentOnIgnoredFilesEmitter {
     ignore_path_set: IgnorePathSet,
     source_map: Rc<SourceMap>,
     emitter: EmitterWriter,
+    can_reset: bool,
+    has_non_ignorable_parser_errors: bool,
 }
 
 impl Emitter for SilentOnIgnoredFilesEmitter {
@@ -709,13 +720,26 @@ impl Emitter for SilentOnIgnoredFilesEmitter {
                         .ignore_path_set
                         .is_match(&FileName::Real(path.to_path_buf()))
                     {
-                        db.handler.reset_err_count();
+                        if !self.has_non_ignorable_parser_errors && !self.can_reset {
+                            let _ = CAN_RESET_CRATE_PARSE_ERRORS.try_with(|r| {
+                                r.set(true);
+                            });
+                            self.can_reset = true;
+                        }
                         return;
                     }
                 }
                 _ => (),
             };
         }
+
+        self.has_non_ignorable_parser_errors = true;
+        if self.can_reset {
+            let _ = CAN_RESET_CRATE_PARSE_ERRORS.try_with(|r| {
+                r.set(false);
+            });
+        }
+        self.can_reset = false;
         self.emitter.emit_diagnostic(db);
     }
 }
@@ -746,9 +770,12 @@ fn make_parse_sess(
         } else {
             ColorConfig::Never
         };
+
         let emitter_writer =
-            EmitterWriter::stderr(color_cfg, Some(source_map.clone()), false, false);
+            EmitterWriter::stderr(color_cfg, Some(source_map.clone()), false, false, None);
         let emitter = Box::new(SilentOnIgnoredFilesEmitter {
+            has_non_ignorable_parser_errors: false,
+            can_reset: false,
             ignore_path_set: ignore_path_set.clone(),
             source_map: source_map.clone(),
             emitter: emitter_writer,

src/test/mod.rs

@@ -27,6 +27,8 @@ const SKIP_FILE_WHITE_LIST: &[&str] = &[
     "configs/skip_children/foo/mod.rs",
     "issue-3434/no_entry.rs",
     "issue-3665/sub_mod.rs",
+    // Testing for issue-3779
+    "issue-3779/ice.rs",
     // These files and directory are a part of modules defined inside `cfg_if!`.
     "cfg_if/mod.rs",
     "cfg_if/detect",

tests/config/issue-3779.toml

@@ -0,0 +1,4 @@
+unstable_features = true
+ignore = [
+  "tests/**/issue-3779/ice.rs"
+]

tests/source/issue-3779/ice.rs

@@ -0,0 +1,3 @@
+pub fn bar() {
+    1x;
+}

tests/source/issue-3779/lib.rs

@@ -0,0 +1,8 @@
+// rustfmt-config: issue-3779.toml
+
+#[path = "ice.rs"]
+mod ice;
+
+fn foo() {
+println!("abc") ;
+    }

tests/target/issue-3779/ice.rs

@@ -0,0 +1,3 @@
+pub fn bar() {
+    1x;
+}

tests/target/issue-3779/lib.rs

@@ -0,0 +1,8 @@
+// rustfmt-config: issue-3779.toml
+
+#[path = "ice.rs"]
+mod ice;
+
+fn foo() {
+    println!("abc");
+}