Share repo walkdir logic between the 2 repo walk tests

benches/rust.rs

@@ -18,6 +18,7 @@
 #[path = "../tests/macros/mod.rs"]
 mod macros;
 
+#[allow(dead_code)]
 #[path = "../tests/repo/mod.rs"]
 mod repo;
 

tests/repo/mod.rs

@@ -5,10 +5,11 @@ mod progress;
 use self::progress::Progress;
 use anyhow::Result;
 use flate2::read::GzDecoder;
+use rayon::iter::{IntoParallelIterator, ParallelIterator};
 use std::fs;
 use std::path::Path;
 use tar::Archive;
-use walkdir::DirEntry;
+use walkdir::{DirEntry, WalkDir};
 
 const REVISION: &str = "5e1d3299a290026b85787bc9c7e72bcc53ac283f";
 
@@ -199,6 +200,17 @@ static EXCLUDE_DIRS: &[&str] = &[
     "src/tools/rust-analyzer/crates/syntax/test_data/reparse/fuzz-failures",
 ];
 
+pub fn for_each_rust_file(for_each: impl Fn(DirEntry) + Sync + Send) {
+    WalkDir::new("tests/rust")
+        .sort_by_file_name()
+        .into_iter()
+        .filter_entry(base_dir_filter)
+        .collect::<Result<Vec<DirEntry>, walkdir::Error>>()
+        .unwrap()
+        .into_par_iter()
+        .for_each(for_each);
+}
+
 pub fn base_dir_filter(entry: &DirEntry) -> bool {
     let path = entry.path();
 

tests/test_precedence.rs

@@ -35,7 +35,6 @@ extern crate thin_vec;
 use crate::common::eq::SpanlessEq;
 use crate::common::parse;
 use quote::quote;
-use rayon::iter::{IntoParallelIterator, ParallelIterator};
 use regex::Regex;
 use rustc_ast::ast;
 use rustc_ast::ptr::P;
@@ -45,7 +44,6 @@ use std::fs;
 use std::path::Path;
 use std::process;
 use std::sync::atomic::{AtomicUsize, Ordering};
-use walkdir::{DirEntry, WalkDir};
 
 #[macro_use]
 mod macros;
@@ -70,48 +68,41 @@ fn test_rustc_precedence() {
     // 2018 edition is hard
     let edition_regex = Regex::new(r"\b(async|try)[!(]").unwrap();
 
-    WalkDir::new("tests/rust")
-        .sort_by_file_name()
-        .into_iter()
-        .filter_entry(repo::base_dir_filter)
-        .collect::<Result<Vec<DirEntry>, walkdir::Error>>()
-        .unwrap()
-        .into_par_iter()
-        .for_each(|entry| {
-            let path = entry.path();
-            if path.is_dir() {
-                return;
-            }
-
-            let content = fs::read_to_string(path).unwrap();
-            let content = edition_regex.replace_all(&content, "_$0");
-
-            let (l_passed, l_failed) = match syn::parse_file(&content) {
-                Ok(file) => {
-                    let edition = repo::edition(path).parse().unwrap();
-                    let exprs = collect_exprs(file);
-                    let (l_passed, l_failed) = test_expressions(path, edition, exprs);
-                    errorf!(
-                        "=== {}: {} passed | {} failed\n",
-                        path.display(),
-                        l_passed,
-                        l_failed,
-                    );
-                    (l_passed, l_failed)
-                }
-                Err(msg) => {
-                    errorf!("\nFAIL {} - syn failed to parse: {}\n", path.display(), msg);
-                    (0, 1)
-                }
-            };
+    repo::for_each_rust_file(|entry| {
+        let path = entry.path();
+        if path.is_dir() {
+            return;
+        }
 
-            passed.fetch_add(l_passed, Ordering::Relaxed);
-            let prev_failed = failed.fetch_add(l_failed, Ordering::Relaxed);
+        let content = fs::read_to_string(path).unwrap();
+        let content = edition_regex.replace_all(&content, "_$0");
 
-            if prev_failed + l_failed >= abort_after {
-                process::exit(1);
+        let (l_passed, l_failed) = match syn::parse_file(&content) {
+            Ok(file) => {
+                let edition = repo::edition(path).parse().unwrap();
+                let exprs = collect_exprs(file);
+                let (l_passed, l_failed) = test_expressions(path, edition, exprs);
+                errorf!(
+                    "=== {}: {} passed | {} failed\n",
+                    path.display(),
+                    l_passed,
+                    l_failed,
+                );
+                (l_passed, l_failed)
             }
-        });
+            Err(msg) => {
+                errorf!("\nFAIL {} - syn failed to parse: {}\n", path.display(), msg);
+                (0, 1)
+            }
+        };
+
+        passed.fetch_add(l_passed, Ordering::Relaxed);
+        let prev_failed = failed.fetch_add(l_failed, Ordering::Relaxed);
+
+        if prev_failed + l_failed >= abort_after {
+            process::exit(1);
+        }
+    });
 
     let passed = passed.load(Ordering::Relaxed);
     let failed = failed.load(Ordering::Relaxed);

tests/test_round_trip.rs

@@ -22,7 +22,6 @@ extern crate rustc_span;
 
 use crate::common::eq::SpanlessEq;
 use quote::quote;
-use rayon::iter::{IntoParallelIterator, ParallelIterator};
 use rustc_ast::ast::{
     AngleBracketedArg, AngleBracketedArgs, Crate, GenericArg, GenericParamKind, Generics,
     WhereClause,
@@ -40,7 +39,6 @@ use std::path::Path;
 use std::process;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::time::Instant;
-use walkdir::{DirEntry, WalkDir};
 
 #[macro_use]
 mod macros;
@@ -61,19 +59,12 @@ fn test_round_trip() {
 
     let failed = AtomicUsize::new(0);
 
-    WalkDir::new("tests/rust")
-        .sort_by_file_name()
-        .into_iter()
-        .filter_entry(repo::base_dir_filter)
-        .collect::<Result<Vec<DirEntry>, walkdir::Error>>()
-        .unwrap()
-        .into_par_iter()
-        .for_each(|entry| {
-            let path = entry.path();
-            if !path.is_dir() {
-                test(path, &failed, abort_after);
-            }
-        });
+    repo::for_each_rust_file(|entry| {
+        let path = entry.path();
+        if !path.is_dir() {
+            test(path, &failed, abort_after);
+        }
+    });
 
     let failed = failed.load(Ordering::Relaxed);
     if failed > 0 {