Update rustc-ap-* crates to 581.0.0 (#3783)

[rust.git] / src / source_file.rs

diff --git a/src/source_file.rs b/src/source_file.rs
index 07c1e37fbedd7155025e7c668426fd0307e0342b..28366ca2485c16f1adadbc3f8d787f16a5efd0a5 100644 (file)
--- a/src/source_file.rs
+++ b/src/source_file.rs
@@ -1,15 +1,21 @@
 use std::fs;
 use std::io::{self, Write};
+use std::path::Path;
 
-use crate::checkstyle::output_checkstyle_file;
-use crate::config::{Config, EmitMode, FileName, Verbosity};
-use crate::rustfmt_diff::{make_diff, output_modified, print_diff};
+use syntax::source_map::SourceMap;
 
+use crate::config::FileName;
+use crate::emitter::{self, Emitter};
+
+#[cfg(test)]
+use crate::config::Config;
+#[cfg(test)]
+use crate::create_emitter;
 #[cfg(test)]
 use crate::formatting::FileRecord;
 
 // Append a newline to the end of each file.
-pub fn append_newline(s: &mut String) {
+pub(crate) fn append_newline(s: &mut String) {
     s.push_str("\n");
 }
 
@@ -22,91 +28,59 @@ pub(crate) fn write_all_files<T>(
 where
     T: Write,
 {
-    if config.emit_mode() == EmitMode::Checkstyle {
-        write!(out, "{}", crate::checkstyle::header())?;
-    }
+    let mut emitter = create_emitter(config);
+
+    emitter.emit_header(out)?;
     for &(ref filename, ref text) in source_file {
-        write_file(text, filename, out, config)?;
-    }
-    if config.emit_mode() == EmitMode::Checkstyle {
-        write!(out, "{}", crate::checkstyle::footer())?;
+        write_file(None, filename, text, out, &mut *emitter)?;
     }
+    emitter.emit_footer(out)?;
 
     Ok(())
 }
 
-pub fn write_file<T>(
-    formatted_text: &str,
+pub(crate) fn write_file<T>(
+    source_map: Option<&SourceMap>,
     filename: &FileName,
+    formatted_text: &str,
     out: &mut T,
-    config: &Config,
-) -> Result<bool, io::Error>
+    emitter: &mut dyn Emitter,
+) -> Result<emitter::EmitterResult, io::Error>
 where
     T: Write,
 {
-    let filename_to_path = || match *filename {
-        FileName::Real(ref path) => path,
-        _ => panic!("cannot format `{}` and emit to files", 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 {
-                // 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.
-                let tmp_name = filename.with_extension("tmp");
-                let bk_name = filename.with_extension("bk");
-
-                fs::write(&tmp_name, formatted_text)?;
-                fs::rename(filename, bk_name)?;
-                fs::rename(tmp_name, filename)?;
-            }
-        }
-        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 {
-                fs::write(filename, formatted_text)?;
-            }
+    fn ensure_real_path(filename: &FileName) -> &Path {
+        match *filename {
+            FileName::Real(ref path) => path,
+            _ => panic!("cannot format `{}` and emit to files", filename),
         }
-        EmitMode::Stdout | EmitMode::Coverage => {
-            if config.verbose() != Verbosity::Quiet {
-                println!("{}:\n", 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()),
             }
-            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 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);
-            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 has_diff = !mismatch.is_empty();
-            print_diff(
-                mismatch,
-                |line_num| format!("Diff in {} at line {}:", filename.display(), line_num),
-                config,
-            );
-            return Ok(has_diff);
         }
     }
 
-    // when we are not in diff mode, don't indicate differing files
-    Ok(false)
+    // 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(ToString::to_string));
+    let original_text = match original_text {
+        Some(ori) => ori,
+        None => fs::read_to_string(ensure_real_path(filename))?,
+    };
+
+    let formatted_file = emitter::FormattedFile {
+        filename,
+        original_text: &original_text,
+        formatted_text,
+    };
+
+    emitter.emit_formatted_file(out, formatted_file)
 }