Allow for stdin input in EmitMode::ModifiedLines

Author: Xanewok

src/formatting.rs

@@ -181,15 +181,20 @@ impl<'a, T: FormatHandler + 'a> FormatContext<'a, T> {
         self.report
             .add_non_formatted_ranges(visitor.skipped_range.clone());
 
-        self.handler
-            .handle_formatted_file(path, visitor.buffer.to_owned(), &mut self.report)
+        self.handler.handle_formatted_file(
+            self.parse_session.source_map(),
+            path,
+            visitor.buffer.to_owned(),
+            &mut self.report,
+        )
     }
 }
 
 // Handle the results of formatting.
 trait FormatHandler {
     fn handle_formatted_file(
         &mut self,
+        source_map: &SourceMap,
         path: FileName,
         result: String,
         report: &mut FormatReport,
@@ -200,13 +205,14 @@ impl<'b, T: Write + 'b> FormatHandler for Session<'b, T> {
     // Called for each formatted file.
     fn handle_formatted_file(
         &mut self,
+        source_map: &SourceMap,
         path: FileName,
         result: String,
         report: &mut FormatReport,
     ) -> Result<(), ErrorKind> {
         if let Some(ref mut out) = self.out {
-            match source_file::write_file(&result, &path, out, &self.config) {
-                Ok(b) if b => report.add_diff(),
+            match source_file::write_file(Some(source_map), &path, &result, out, &self.config) {
+                Ok(has_diff) if has_diff => report.add_diff(),
                 Err(e) => {
                     // Create a new error with path_str to help users see which files failed
                     let err_msg = format!("{}: {}", path, e);
@@ -299,7 +305,7 @@ impl FormattingError {
 
 pub(crate) type FormatErrorMap = HashMap<FileName, Vec<FormattingError>>;
 
-#[derive(Default, Debug)]
+#[derive(Default, Debug, PartialEq)]
 pub(crate) struct ReportedErrors {
     // Encountered e.g., an IO error.
     pub(crate) has_operational_errors: bool,

src/lib.rs

@@ -33,6 +33,8 @@ pub use crate::config::{
     Range, Verbosity,
 };
 
+pub use crate::rustfmt_diff::make_diff;
+
 #[macro_use]
 mod utils;
 

src/source_file.rs

@@ -1,5 +1,8 @@
 use std::fs;
 use std::io::{self, Write};
+use std::path::Path;
+
+use syntax::source_map::SourceMap;
 
 use crate::checkstyle::output_checkstyle_file;
 use crate::config::{Config, EmitMode, FileName, Verbosity};
@@ -26,7 +29,7 @@ where
         write!(out, "{}", crate::checkstyle::header())?;
     }
     for &(ref filename, ref text) in source_file {
-        write_file(text, filename, out, config)?;
+        write_file(None, filename, text, out, config)?;
     }
     if config.emit_mode() == EmitMode::Checkstyle {
         write!(out, "{}", crate::checkstyle::footer())?;
@@ -36,24 +39,46 @@ where
 }
 
 pub fn write_file<T>(
-    formatted_text: &str,
+    source_map: Option<&SourceMap>,
     filename: &FileName,
+    formatted_text: &str,
     out: &mut T,
     config: &Config,
 ) -> Result<bool, io::Error>
 where
     T: Write,
 {
-    let filename_to_path = || match *filename {
-        FileName::Real(ref path) => path,
-        _ => panic!("cannot format `{}` and emit to files", filename),
+    fn ensure_real_path(filename: &FileName) -> &Path {
+        match *filename {
+            FileName::Real(ref path) => path,
+            _ => panic!("cannot format `{}` and emit to files", filename),
+        }
+    }
+
+    impl From<&FileName> for syntax_pos::FileName {
+        fn from(filename: &FileName) -> syntax_pos::FileName {
+            match filename {
+                FileName::Real(path) => syntax_pos::FileName::Real(path.to_owned()),
+                FileName::Stdin => syntax_pos::FileName::Custom("stdin".to_owned()),
+            }
+        }
+    }
+
+    // If parse session is around (cfg(not(test))) then try getting source from
+    // there instead of hitting the file system. This also supports getting
+    // original text for `FileName::Stdin`.
+    let original_text = source_map
+        .and_then(|x| x.get_source_file(&filename.into()))
+        .and_then(|x| x.src.as_ref().map(|x| x.to_string()));
+    let original_text = match original_text {
+        Some(ori) => ori,
+        None => fs::read_to_string(ensure_real_path(filename))?,
     };
 
     match config.emit_mode() {
         EmitMode::Files if config.make_backup() => {
-            let filename = filename_to_path();
-            let ori = fs::read_to_string(filename)?;
-            if ori != formatted_text {
+            let filename = ensure_real_path(filename);
+            if original_text != formatted_text {
                 // Do a little dance to make writing safer - write to a temp file
                 // rename the original to a .bk, then rename the temp file to the
                 // original.
@@ -67,9 +92,9 @@ where
         }
         EmitMode::Files => {
             // Write text directly over original file if there is a diff.
-            let filename = filename_to_path();
-            let ori = fs::read_to_string(filename)?;
-            if ori != formatted_text {
+            let filename = ensure_real_path(filename);
+
+            if original_text != formatted_text {
                 fs::write(filename, formatted_text)?;
             }
         }
@@ -80,27 +105,23 @@ where
             write!(out, "{}", formatted_text)?;
         }
         EmitMode::ModifiedLines => {
-            let filename = filename_to_path();
-            let ori = fs::read_to_string(filename)?;
-            let mismatch = make_diff(&ori, formatted_text, 0);
+            let mismatch = make_diff(&original_text, formatted_text, 0);
             let has_diff = !mismatch.is_empty();
             output_modified(out, mismatch);
             return Ok(has_diff);
         }
         EmitMode::Checkstyle => {
-            let filename = filename_to_path();
-            let ori = fs::read_to_string(filename)?;
-            let diff = make_diff(&ori, formatted_text, 3);
+            let filename = ensure_real_path(filename);
+
+            let diff = make_diff(&original_text, formatted_text, 3);
             output_checkstyle_file(out, filename, diff)?;
         }
         EmitMode::Diff => {
-            let filename = filename_to_path();
-            let ori = fs::read_to_string(filename)?;
-            let mismatch = make_diff(&ori, formatted_text, 3);
+            let mismatch = make_diff(&original_text, formatted_text, 3);
             let has_diff = !mismatch.is_empty();
             print_diff(
                 mismatch,
-                |line_num| format!("Diff in {} at line {}:", filename.display(), line_num),
+                |line_num| format!("Diff in {} at line {}:", filename, line_num),
                 config,
             );
             return Ok(has_diff);

src/test/mod.rs

@@ -9,7 +9,7 @@ use std::process::{Command, Stdio};
 use std::str::Chars;
 
 use crate::config::{Color, Config, EmitMode, FileName, ReportTactic};
-use crate::formatting::{ModifiedChunk, SourceFile};
+use crate::formatting::{ModifiedChunk, ReportedErrors, SourceFile};
 use crate::rustfmt_diff::{make_diff, print_diff, DiffLine, Mismatch, OutputWriter};
 use crate::source_file;
 use crate::{FormatReport, Input, Session};
@@ -290,6 +290,30 @@ fn stdin_parser_panic_caught() {
     }
 }
 
+/// Ensures that `EmitMode::ModifiedLines` works with input from `stdin`. Useful
+/// when embedding Rustfmt (e.g. inside RLS).
+#[test]
+fn stdin_works_with_modified_lines() {
+    let input = "\nfn\n some( )\n{\n}\nfn main () {}\n";
+    let output = "1 6 2\nfn some() {}\nfn main() {}\n";
+
+    let input = Input::Text(input.to_owned());
+    let mut config = Config::default();
+    config.set().emit_mode(EmitMode::ModifiedLines);
+    let mut buf: Vec<u8> = vec![];
+    {
+        let mut session = Session::new(config, Some(&mut buf));
+        session.format(input).unwrap();
+        let errors = ReportedErrors {
+            has_diff: true,
+            ..Default::default()
+        };
+        assert_eq!(session.errors, errors);
+    }
+    let newline = if cfg!(windows) { "\r\n" } else { "\n" };
+    assert_eq!(buf, output.replace('\n', newline).as_bytes());
+}
+
 #[test]
 fn stdin_disable_all_formatting_test() {
     match option_env!("CFG_RELEASE_CHANNEL") {