Move filters to comment defaults

Author: oli-obk

CHANGELOG.md

@@ -22,5 +22,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 * `$DIR` and `RUSTLIB` replacements
 * `Config::edition` (replaced by `config.comment_defaults.base().edition`)
+* `Config::filter_stdout` (replaced by `config.comment_defaults.base().normalize_stdout`)
+* `Config::filter_stderr` (replaced by `config.comment_defaults.base().normalize_stderr`)
 
 ## [0.21.2] - 2023-09-27

src/config.rs

@@ -2,8 +2,8 @@ use regex::bytes::Regex;
 use spanned::Span;
 
 use crate::{
-    dependencies::build_dependencies, per_test_config::Comments, CommandBuilder, Filter, Match,
-    Mode, RustfixMode,
+    dependencies::build_dependencies, per_test_config::Comments, CommandBuilder, Match, Mode,
+    RustfixMode,
 };
 pub use color_eyre;
 use color_eyre::eyre::Result;
@@ -23,14 +23,6 @@ pub struct Config {
     pub host: Option<String>,
     /// `None` to run on the host, otherwise a target triple
     pub target: Option<String>,
-    /// Filters applied to stderr output before processing it.
-    /// By default contains a filter for replacing backslashes in paths with
-    /// regular slashes.
-    /// On windows, contains a filter to remove `\r`.
-    pub stderr_filters: Filter,
-    /// Filters applied to stdout output before processing it.
-    /// On windows, contains a filter to remove `\r`.
-    pub stdout_filters: Filter,
     /// The folder in which to start searching for .rs files
     pub root_dir: PathBuf,
     /// The mode in which to run the tests.
@@ -74,23 +66,18 @@ impl Config {
             .base()
             .edition
             .set("2021".into(), Span::default());
+        let filters = vec![
+            (Match::PathBackslash, b"/".to_vec()),
+            #[cfg(windows)]
+            (Match::Exact(vec![b'\r']), b"".to_vec()),
+            #[cfg(windows)]
+            (Match::Exact(br"\\?\".to_vec()), b"".to_vec()),
+        ];
+        let _ = comment_defaults.base().normalize_stderr = filters.clone();
+        let _ = comment_defaults.base().normalize_stdout = filters;
         Self {
             host: None,
             target: None,
-            stderr_filters: vec![
-                (Match::PathBackslash, b"/"),
-                #[cfg(windows)]
-                (Match::Exact(vec![b'\r']), b""),
-                #[cfg(windows)]
-                (Match::Exact(br"\\?\".to_vec()), b""),
-            ],
-            stdout_filters: vec![
-                (Match::PathBackslash, b"/"),
-                #[cfg(windows)]
-                (Match::Exact(vec![b'\r']), b""),
-                #[cfg(windows)]
-                (Match::Exact(br"\\?\".to_vec()), b""),
-            ],
             root_dir: root_dir.into(),
             mode: Mode::Fail {
                 require_patterns: true,
@@ -118,15 +105,16 @@ impl Config {
     /// Create a configuration for testing the output of running
     /// `cargo` on the test `Cargo.toml` files.
     pub fn cargo(root_dir: impl Into<PathBuf>) -> Self {
-        Self {
+        let mut this = Self {
             program: CommandBuilder::cargo(),
-            comment_defaults: Comments::default(),
             mode: Mode::Fail {
                 require_patterns: true,
                 rustfix: RustfixMode::Disabled,
             },
             ..Self::rustc(root_dir)
-        }
+        };
+        this.comment_defaults.base().edition = Default::default();
+        this
     }
 
     /// Populate the config with the values from parsed command line arguments.
@@ -189,8 +177,10 @@ impl Config {
         replacement: &'static (impl AsRef<[u8]> + ?Sized),
     ) {
         let pattern = path.canonicalize().unwrap();
-        self.stderr_filters
-            .push((pattern.parent().unwrap().into(), replacement.as_ref()));
+        self.comment_defaults.base().normalize_stderr.push((
+            pattern.parent().unwrap().into(),
+            replacement.as_ref().to_owned(),
+        ));
     }
 
     /// Replace all occurrences of a path in stdout with a byte string.
@@ -201,8 +191,10 @@ impl Config {
         replacement: &'static (impl AsRef<[u8]> + ?Sized),
     ) {
         let pattern = path.canonicalize().unwrap();
-        self.stdout_filters
-            .push((pattern.parent().unwrap().into(), replacement.as_ref()));
+        self.comment_defaults.base().normalize_stdout.push((
+            pattern.parent().unwrap().into(),
+            replacement.as_ref().to_owned(),
+        ));
     }
 
     /// Replace all occurrences of a regex pattern in stderr/stdout with a byte string.
@@ -219,8 +211,10 @@ impl Config {
         pattern: &str,
         replacement: &'static (impl AsRef<[u8]> + ?Sized),
     ) {
-        self.stderr_filters
-            .push((Regex::new(pattern).unwrap().into(), replacement.as_ref()));
+        self.comment_defaults.base().normalize_stderr.push((
+            Regex::new(pattern).unwrap().into(),
+            replacement.as_ref().to_owned(),
+        ));
     }
 
     /// Replace all occurrences of a regex pattern in stdout with a byte string.
@@ -230,8 +224,10 @@ impl Config {
         pattern: &str,
         replacement: &'static (impl AsRef<[u8]> + ?Sized),
     ) {
-        self.stdout_filters
-            .push((Regex::new(pattern).unwrap().into(), replacement.as_ref()));
+        self.comment_defaults.base().normalize_stdout.push((
+            Regex::new(pattern).unwrap().into(),
+            replacement.as_ref().to_owned(),
+        ));
     }
 
     /// Compile dependencies and return the right flags

src/lib.rs

@@ -111,9 +111,6 @@ impl From<Regex> for Match {
     }
 }
 
-/// Replacements to apply to output files.
-pub type Filter = Vec<(Match, &'static [u8])>;
-
 /// Run all tests as described in the config argument.
 /// Will additionally process command line arguments.
 pub fn run_tests(mut config: Config) -> Result<()> {
@@ -931,7 +928,6 @@ fn run_rustfix(
         path,
         &mut errors,
         "fixed",
-        &Filter::default(),
         config,
         &rustfix_comments,
         revision,
@@ -1040,26 +1036,8 @@ fn check_test_output(
 ) {
     // Check output files (if any)
     // Check output files against actual output
-    check_output(
-        stderr,
-        path,
-        errors,
-        "stderr",
-        &config.stderr_filters,
-        config,
-        comments,
-        revision,
-    );
-    check_output(
-        stdout,
-        path,
-        errors,
-        "stdout",
-        &config.stdout_filters,
-        config,
-        comments,
-        revision,
-    );
+    check_output(stderr, path, errors, "stderr", config, comments, revision);
+    check_output(stdout, path, errors, "stdout", config, comments, revision);
 }
 
 fn check_annotations(
@@ -1197,13 +1175,12 @@ fn check_output(
     path: &Path,
     errors: &mut Errors,
     kind: &'static str,
-    filters: &Filter,
     config: &Config,
     comments: &Comments,
     revision: &str,
 ) -> PathBuf {
     let target = config.target.as_ref().unwrap();
-    let output = normalize(output, filters, comments, revision, kind);
+    let output = normalize(output, comments, revision, kind);
     let path = output_path(path, comments, revised(revision, kind), target, revision);
     match &config.output_conflict_handling {
         OutputConflictHandling::Error(bless_command) => {
@@ -1293,19 +1270,9 @@ fn get_pointer_width(triple: &str) -> u8 {
     }
 }
 
-fn normalize(
-    text: &[u8],
-    filters: &Filter,
-    comments: &Comments,
-    revision: &str,
-    kind: &'static str,
-) -> Vec<u8> {
+fn normalize(text: &[u8], comments: &Comments, revision: &str, kind: &'static str) -> Vec<u8> {
     let mut text = text.to_owned();
 
-    for (rule, replacement) in filters {
-        text = rule.replace_all(&text, replacement).into_owned();
-    }
-
     for (from, to) in comments.for_revision(revision).flat_map(|r| match kind {
         "fixed" => &[] as &[_],
         "stderr" => &r.normalize_stderr,

src/parser.rs

@@ -8,7 +8,7 @@ use std::{
 use bstr::{ByteSlice, Utf8Error};
 use regex::bytes::Regex;
 
-use crate::{rustc_stderr::Level, Error, Errored, Mode};
+use crate::{rustc_stderr::Level, Error, Errored, Match, Mode};
 
 use color_eyre::eyre::{Context, Result};
 
@@ -118,9 +118,9 @@ pub struct Revisioned {
     /// Additional env vars to set for the executable
     pub env_vars: Vec<(String, String)>,
     /// Normalizations to apply to the stderr output before emitting it to disk
-    pub normalize_stderr: Vec<(Regex, Vec<u8>)>,
+    pub normalize_stderr: Vec<(Match, Vec<u8>)>,
     /// Normalizations to apply to the stdout output before emitting it to disk
-    pub normalize_stdout: Vec<(Regex, Vec<u8>)>,
+    pub normalize_stdout: Vec<(Match, Vec<u8>)>,
     /// Arbitrary patterns to look for in the stderr.
     /// The error must be from another file, as errors from the current file must be
     /// checked via `error_matches`.
@@ -506,13 +506,13 @@ impl CommentParser<&mut Revisioned> {
                 }
             }
             "normalize-stderr-test" => (this, args, _span){
-                if let Some(res) = this.parse_normalize_test(args, "stderr") {
-                    this.normalize_stderr.push(res)
+                if let Some((regex, replacement)) = this.parse_normalize_test(args, "stderr") {
+                    this.normalize_stderr.push((regex.into(), replacement))
                 }
             }
             "normalize-stdout-test" => (this, args, _span){
-                if let Some(res) = this.parse_normalize_test(args, "stdout") {
-                    this.normalize_stdout.push(res)
+                if let Some((regex, replacement)) = this.parse_normalize_test(args, "stdout") {
+                    this.normalize_stdout.push((regex.into(), replacement))
                 }
             }
             "error-pattern" => (this, _args, span){

tests/integration.rs

@@ -52,8 +52,10 @@ fn main() -> Result<()> {
     // Insert the replacement filter at the start to make sure the filter for single backslashes
     // runs afterwards.
     config
-        .stdout_filters
-        .insert(0, (Match::Exact(b"\\\\".to_vec()), b"\\"));
+        .comment_defaults
+        .base()
+        .normalize_stdout
+        .insert(0, (Match::Exact(b"\\\\".to_vec()), b"\\".to_vec()));
     config.stdout_filter(r#"(panic.*)\.rs:[0-9]+:[0-9]+"#, "$1.rs");
     // We don't want to normalize lines starting with `+`, those are diffs of the inner ui_test
     // and normalizing these here doesn't make the "actual output differed from expected" go