feat: don't format w/invalid attributes

Author: calebcartwright

src/formatting/report.rs

@@ -78,6 +78,10 @@ impl FormatResult {
     pub(crate) fn formatted_snippet(&self) -> &FormattedSnippet {
         &self.formatted_snippet
     }
+
+    pub(crate) fn has_error_kind(&self, kind: ErrorKind) -> bool {
+        self.all_errors().any(|e| e.kind() == kind)
+    }
 }
 
 impl FormatReport {
@@ -154,6 +158,16 @@ impl FormatReport {
             .insert(format_error);
     }
 
+    fn has_error_kind(&self, kind: ErrorKind) -> bool {
+        RefCell::borrow(&self.format_result)
+            .iter()
+            .any(|(_, format_result)| format_result.has_error_kind(kind))
+    }
+
+    pub fn has_invalid_rustfmt_attribute_errors(&self) -> bool {
+        self.has_error_kind(ErrorKind::BadAttr)
+    }
+
     pub fn has_errors(&self) -> bool {
         RefCell::borrow(&self.format_result)
             .iter()

src/rustfmt/main.rs

@@ -92,6 +92,11 @@ struct Opt {
     /// Print verbose output.
     #[structopt(short, long)]
     verbose: bool,
+    /// Continue with formatting even if there are invalid rustfmt attributes.
+    ///
+    /// Exits with 1 if there are any invalid rustfmt attributes.
+    #[structopt(long = "format-with-invalid-attrs")]
+    format_with_invalid_attributes: bool,
 
     // Nightly-only options.
     /// Limit formatting to specified ranges.
@@ -413,6 +418,10 @@ fn format_string(input: String, opt: Opt) -> Result<i32> {
         verbosity: Verbosity::Quiet,
     };
     let report = rustfmt_nightly::format(Input::Text(input), &config, setting)?;
+    if report.has_invalid_rustfmt_attribute_errors() && !opt.format_with_invalid_attributes {
+        eprintln!("Input contained invalid rustfmt attributes");
+        return Ok(1);
+    }
     let has_diff = emit_format_report(report, out, opt.emitter_config(EmitMode::Stdout))?;
     Ok(if opt.check && has_diff { 1 } else { 0 })
 }
@@ -521,6 +530,10 @@ fn format(opt: Opt) -> Result<i32> {
         );
     }
 
+    if format_report.has_invalid_rustfmt_attribute_errors() && !opt.format_with_invalid_attributes {
+        return Ok(1);
+    }
+
     let has_diff = emit_format_report(
         format_report,
         &mut stdout(),
@@ -543,7 +556,16 @@ mod test {
         path: PathBuf,
     }
 
-    fn make_temp_file(file_name: &'static str) -> TempFile {
+    fn assert_temp_file_contents(expected_contents: &[u8], actual_file: TempFile) {
+        assert_eq!(
+            expected_contents,
+            std::fs::read_to_string(&actual_file.path)
+                .expect("couldn't read temp file")
+                .as_bytes(),
+        );
+    }
+
+    fn make_temp_file_with_contents(file_name: &'static str, content: &[u8]) -> TempFile {
         use std::env::var;
         use std::fs::File;
 
@@ -552,11 +574,14 @@ mod test {
         let path = Path::new(&target_dir).join(file_name);
 
         let mut file = File::create(&path).expect("couldn't create temp file");
-        let content = b"fn main() {}\n";
         file.write_all(content).expect("couldn't write temp file");
         TempFile { path }
     }
 
+    fn make_temp_file(file_name: &'static str) -> TempFile {
+        make_temp_file_with_contents(file_name, b"fn main() {}\n")
+    }
+
     impl Drop for TempFile {
         fn drop(&mut self) {
             use std::fs::remove_file;
@@ -680,4 +705,112 @@ mod test {
             .expect("Failed to wait on rustfmt child");
         assert!(output.status.success());
     }
+
+    #[cfg(test)]
+    mod format_with_invalid_attributes {
+        use super::*;
+
+        const CONTENTS: &[u8] = br#"
+        #![rustfmt::max_width(120)]
+        fn foo() {
+        println!("bar");
+        }
+        "#;
+
+        const FORMATTED_CONTENTS: &[u8] = br#"
+#![rustfmt::max_width(120)]
+fn foo() {
+    println!("bar");
+}
+"#;
+
+        #[test]
+        fn verify_default() {
+            init_log();
+            let temp_file = make_temp_file_with_contents("temp_invalid_attrs.rs", CONTENTS);
+
+            let child = Command::new(rustfmt())
+                .arg(&temp_file.path)
+                .stderr(Stdio::piped())
+                .spawn()
+                .expect("run with --format-with-invalid-attrs option failed");
+            let output = child
+                .wait_with_output()
+                .expect("Failed to wait on rustfmt child");
+
+            assert!(!output.status.success());
+            assert_temp_file_contents(CONTENTS, temp_file);
+        }
+
+        #[test]
+        fn verify_enabled() {
+            init_log();
+            let temp_file = make_temp_file_with_contents("temp_invalid_attrs_enabled.rs", CONTENTS);
+
+            let child = Command::new(rustfmt())
+                .arg(&temp_file.path)
+                .arg("--format-with-invalid-attrs")
+                .stderr(Stdio::piped())
+                .spawn()
+                .expect("run with --format-with-invalid-attrs option failed");
+            let output = child
+                .wait_with_output()
+                .expect("Failed to wait on rustfmt child");
+            assert!(output.status.success());
+            assert_temp_file_contents(FORMATTED_CONTENTS, temp_file);
+        }
+
+        #[test]
+        fn verify_default_stdin() {
+            init_log();
+
+            let mut child = Command::new(rustfmt())
+                .stdin(Stdio::piped())
+                .stdout(Stdio::piped())
+                .stderr(Stdio::piped())
+                .spawn()
+                .expect("run with check option failed");
+
+            {
+                let stdin = child.stdin.as_mut().expect("Failed to open stdin");
+                stdin
+                    .write_all(CONTENTS)
+                    .expect("Failed to write to rustfmt --check");
+            }
+            let output = child
+                .wait_with_output()
+                .expect("Failed to wait on rustfmt child");
+            assert!(!output.status.success());
+            assert!(output.stdout.is_empty());
+            assert_eq!(
+                String::from_utf8(output.stderr).unwrap(),
+                String::from("Input contained invalid rustfmt attributes\n")
+            );
+        }
+
+        #[test]
+        fn verify_enabled_stdin() {
+            init_log();
+
+            let mut child = Command::new(rustfmt())
+                .arg("--format-with-invalid-attrs")
+                .stdin(Stdio::piped())
+                .stdout(Stdio::piped())
+                .stderr(Stdio::piped())
+                .spawn()
+                .expect("run with check option failed");
+
+            {
+                let stdin = child.stdin.as_mut().expect("Failed to open stdin");
+                stdin
+                    .write_all(CONTENTS)
+                    .expect("Failed to write to rustfmt --check");
+            }
+            let output = child
+                .wait_with_output()
+                .expect("Failed to wait on rustfmt child");
+            assert!(output.status.success());
+            assert_eq!(&output.stdout, &FORMATTED_CONTENTS);
+        }
+    }
 }