Add --stdin-file-hint rustfmt command line option

When formatting files via stdin rustfmt didn't have a way to ignore
stdin input.

Now, when passing input to rustfmt via stdin one can also provide the
`--stdin-file-hint` option to inform rustfmt that the input is actually
from the hinted at file. rustfmt now uses this hint to determine if it
can ignore formatting stdin.

Note: This option is intended for text editor plugins that call rustfmt
by passing input via stdin (e.g. rust-analyzer).

Author: ytmimi

src/bin/main.rs

@@ -78,6 +78,22 @@ pub enum OperationError {
     /// supported with stdandard input.
     #[error("Emit mode {0} not supported with standard output.")]
     StdinBadEmit(EmitMode),
+    /// Using `--std-file-hint` incorrectly
+    #[error("{0}")]
+    StdInFileHint(StdInFileHintError),
+}
+
+#[derive(Error, Debug)]
+pub enum StdInFileHintError {
+    /// The file hint does not exist
+    #[error("`--std-file-hint={0:?}` could not be found")]
+    NotFound(PathBuf),
+    /// The file hint isn't a rust file
+    #[error("`--std-file-hint={0:?}` is not a rust file")]
+    NotRustFile(PathBuf),
+    /// Attempted to pass --std-file-hint without passing input through stdin
+    #[error("Cannot use `--std-file-hint` without formatting input from stdin.")]
+    NotFormttingWithStdIn,
 }
 
 impl From<IoError> for OperationError {
@@ -144,6 +160,14 @@ fn make_opts() -> Options {
         "Set options from command line. These settings take priority over .rustfmt.toml",
         "[key1=val1,key2=val2...]",
     );
+    opts.optopt(
+        "",
+        "stdin-file-hint",
+        "Inform rustfmt that the text passed to stdin is from the given file. \
+        This option can only be passed when formatting text via stdin, \
+        and the file name is used to determine if rustfmt can skip formatting the input.",
+        "[Path to a rust file.]",
+    );
 
     if is_nightly {
         opts.optflag(
@@ -250,6 +274,11 @@ fn format_string(input: String, options: GetOptsOptions) -> Result<i32> {
     // try to read config from local directory
     let (mut config, _) = load_config(Some(Path::new(".")), Some(options.clone()))?;
 
+    if rustfmt::is_std_ignored(options.stdin_file_hint, &config.ignore()) {
+        io::stdout().write_all(input.as_bytes())?;
+        return Ok(0);
+    }
+
     if options.check {
         config.set().emit_mode(EmitMode::Diff);
     } else {
@@ -490,6 +519,13 @@ fn determine_operation(matches: &Matches) -> Result<Operation, OperationError> {
         return Ok(Operation::Stdin { input: buffer });
     }
 
+    // User's can only pass `--stdin-file-hint` when formating files via stdin.
+    if matches.opt_present("stdin-file-hint") {
+        return Err(OperationError::StdInFileHint(
+            StdInFileHintError::NotFormttingWithStdIn,
+        ));
+    }
+
     Ok(Operation::Format {
         files,
         minimal_config_path,
@@ -515,6 +551,7 @@ struct GetOptsOptions {
     unstable_features: bool,
     error_on_unformatted: Option<bool>,
     print_misformatted_file_names: bool,
+    stdin_file_hint: Option<PathBuf>,
 }
 
 impl GetOptsOptions {
@@ -564,6 +601,20 @@ impl GetOptsOptions {
         }
 
         options.config_path = matches.opt_str("config-path").map(PathBuf::from);
+        options.stdin_file_hint = matches.opt_str("stdin-file-hint").map(PathBuf::from);
+
+        // return early if there are issues with the file hint specified
+        if let Some(file_hint) = &options.stdin_file_hint {
+            if !file_hint.exists() {
+                return Err(StdInFileHintError::NotFound(file_hint.to_owned()))?;
+            }
+
+            if let Some(ext) = file_hint.extension() {
+                if ext != "rs" {
+                    return Err(StdInFileHintError::NotRustFile(file_hint.to_owned()))?;
+                }
+            }
+        }
 
         options.inline_config = matches
             .opt_strs("config")

src/config/options.rs

@@ -391,6 +391,14 @@ impl IgnoreList {
     pub fn rustfmt_toml_path(&self) -> &Path {
         &self.rustfmt_toml_path
     }
+
+    pub fn is_empty(&self) -> bool {
+        self.path_set.is_empty()
+    }
+
+    pub fn contains<P: AsRef<Path>>(&self, path: P) -> bool {
+        self.path_set.contains(path.as_ref())
+    }
 }
 
 impl FromStr for IgnoreList {

src/ignore_path.rs

@@ -1,3 +1,5 @@
+use std::path::{Path, PathBuf};
+
 use ignore::{self, gitignore};
 
 use crate::config::{FileName, IgnoreList};
@@ -30,16 +32,45 @@ impl IgnorePathSet {
     }
 }
 
+/// Determine if input from stdin should be ignored by rustfmt.
+/// See the `ignore` configuration options for details on specifying ignore files.
+pub fn is_std_ignored(file_hint: Option<PathBuf>, ignore_list: &IgnoreList) -> bool {
+    // trivially return false, because no files are ignored
+    if ignore_list.is_empty() {
+        return false;
+    }
+
+    // trivially return true, because everything is ignored when "/" is in the ignore list
+    if ignore_list.contains(Path::new("/")) {
+        return true;
+    }
+
+    // See if the hinted stdin input is an ignored file.
+    if let Some(std_file_hint) = file_hint {
+        let file = FileName::Real(std_file_hint);
+        match IgnorePathSet::from_ignore_list(ignore_list) {
+            Ok(ignore_set) if ignore_set.is_match(&file) => {
+                debug!("{:?} is ignored", file);
+                return true;
+            }
+            _ => {}
+        }
+    }
+    false
+}
+
 #[cfg(test)]
 mod test {
+    use super::*;
+    use crate::config::Config;
     use rustfmt_config_proc_macro::nightly_only_test;
+    use std::path::{Path, PathBuf};
 
     #[nightly_only_test]
     #[test]
     fn test_ignore_path_set() {
-        use crate::config::{Config, FileName};
+        use crate::config::FileName;
         use crate::ignore_path::IgnorePathSet;
-        use std::path::{Path, PathBuf};
 
         let config =
             Config::from_toml(r#"ignore = ["foo.rs", "bar_dir/*"]"#, Path::new("")).unwrap();
@@ -49,4 +80,37 @@ mod test {
         assert!(ignore_path_set.is_match(&FileName::Real(PathBuf::from("bar_dir/baz.rs"))));
         assert!(!ignore_path_set.is_match(&FileName::Real(PathBuf::from("src/bar.rs"))));
     }
+
+    #[test]
+    fn test_is_std_ignored() {
+        let config =
+            Config::from_toml(r#"ignore = ["foo.rs", "bar_dir/*"]"#, Path::new("")).unwrap();
+
+        assert!(is_std_ignored(
+            Some(PathBuf::from("foo.rs")),
+            &config.ignore()
+        ));
+        assert!(is_std_ignored(
+            Some(PathBuf::from("src/foo.rs")),
+            &config.ignore()
+        ));
+        assert!(is_std_ignored(
+            Some(PathBuf::from("bar_dir/bar/bar.rs")),
+            &config.ignore()
+        ));
+
+        assert!(!is_std_ignored(
+            Some(PathBuf::from("baz.rs")),
+            &config.ignore()
+        ));
+        assert!(!is_std_ignored(
+            Some(PathBuf::from("src/baz.rs")),
+            &config.ignore()
+        ));
+        assert!(!is_std_ignored(
+            Some(PathBuf::from("baz_dir/baz/baz.rs")),
+            &config.ignore()
+        ));
+        assert!(!is_std_ignored(None, &config.ignore()));
+    }
 }

src/lib.rs

@@ -68,6 +68,7 @@ mod expr;
 mod format_report_formatter;
 pub(crate) mod formatting;
 mod ignore_path;
+pub use ignore_path::is_std_ignored;
 mod imports;
 mod issues;
 mod items;

tests/config/stdin-file-hint-ignore.toml

@@ -0,0 +1,3 @@
+ignore = [
+  "src/lib.rs"
+]

tests/rustfmt/main.rs

@@ -215,4 +215,67 @@ r#"fn main() {
         let (stdout, _stderr) = rustfmt_std_input(&args, source);
         assert!(stdout.trim_end() == source)
     }
+
+    #[test]
+    fn input_ignored_when_stdin_file_hint_is_ignored() {
+        // NOTE: the source is not properly formatted, but we're giving rustfmt a hint that
+        // the input actually corresponds to `src/lib.rs`, which is ignored in the given config file
+        let args = [
+            "--stdin-file-hint",
+            "src/lib.rs",
+            "--config-path",
+            "tests/config/stdin-file-hint-ignore.toml",
+        ];
+        let source = "fn main     () {    println!(\"hello world!\"); }";
+        let (stdout, _stderr) = rustfmt_std_input(&args, source);
+        assert!(stdout.trim_end() == source)
+    }
+
+    #[rustfmt::skip]
+    #[test]
+    fn input_formatted_when_stdin_file_hint_is_not_ignored() {
+        // NOTE: `src/bin/main.rs` is not ignored in the config file so the input is formatted.
+        let args = [
+            "--stdin-file-hint",
+            "src/bin/main.rs",
+            "--config-path",
+            "tests/config/stdin-file-hint-ignore.toml",
+        ];
+        let source = "fn main     () {    println!(\"hello world!\"); }";
+        let (stdout, _stderr) = rustfmt_std_input(&args, source);
+        let expected_output =
+r#"fn main() {
+    println!("hello world!");
+}"#;
+        assert!(stdout.contains(expected_output))
+    }
+}
+
+mod stdin_file_hint {
+    use super::{rustfmt, rustfmt_std_input};
+
+    #[test]
+    fn error_not_a_rust_file() {
+        let args = ["--stdin-file-hint", "README.md"];
+        let source = "fn main() {}";
+        let (_stdout, stderr) = rustfmt_std_input(&args, source);
+        assert!(stderr.contains("`--std-file-hint=\"README.md\"` is not a rust file"))
+    }
+
+    #[test]
+    fn error_file_not_found() {
+        let args = ["--stdin-file-hint", "does_not_exist.rs"];
+        let source = "fn main() {}";
+        let (_stdout, stderr) = rustfmt_std_input(&args, source);
+        assert!(stderr.contains("`--std-file-hint=\"does_not_exist.rs\"` could not be found"))
+    }
+
+    #[test]
+    fn cant_use_stdin_file_hint_with_rustfmt_file_format() {
+        let args = ["--stdin-file-hint", "src/lib.rs", "src/lib.rs"];
+        let (_stdout, stderr) = rustfmt(&args);
+        assert!(
+            stderr.contains("Cannot use `--std-file-hint` without formatting input from stdin.")
+        );
+    }
 }