Test that all interned symbols are referenced in Clippy sources

Author: samueltardieu

Cargo.toml

@@ -50,7 +50,7 @@ quote = "1.0.25"
 syn = { version = "2.0", features = ["full"] }
 futures = "0.3"
 parking_lot = "0.12"
-tokio = { version = "1", features = ["io-util"] }
+tokio = { version = "1", features = ["io-util", "fs", "rt-multi-thread", "macros"] }
 
 [build-dependencies]
 rustc_tools_util = { path = "rustc_tools_util", version = "0.4.2" }

clippy_utils/src/sym.rs

@@ -132,7 +132,6 @@ generate! {
     enum_glob_use,
     enumerate,
     err,
-    error,
     exp,
     expect_err,
     expn_data,

tests/symbols-used.rs

@@ -0,0 +1,95 @@
+// This test checks that all symbols defined in Clippy's `sym.rs` file
+// are used in Clippy. Otherwise, it will fail with a list of symbols
+// which are unused.
+//
+// This test is a no-op if run as part of the compiler test suite
+// and will always succeed.
+
+use std::collections::HashSet;
+use std::path::Path;
+
+use futures::StreamExt;
+use futures::stream::FuturesUnordered;
+use regex::Regex;
+use walkdir::{DirEntry, WalkDir};
+
+const SYM_FILE: &str = "clippy_utils/src/sym.rs";
+
+type Result<T, E = AnyError> = std::result::Result<T, E>;
+type AnyError = Box<dyn std::error::Error>;
+
+async fn load_interned_symbols() -> Result<HashSet<String>> {
+    let content = tokio::fs::read_to_string(SYM_FILE).await?;
+    let content = content
+        .split_once("generate! {")
+        .ok_or("cannot find symbols start")?
+        .1
+        .split_once("\n}\n")
+        .ok_or("cannot find symbols end")?
+        .0;
+    let re = Regex::new(r"(?m)^    (\w+)").unwrap();
+    Ok(re.captures_iter(content).map(|m| m[1].to_owned()).collect())
+}
+
+async fn load_symbols(file: impl AsRef<Path>, re: &Regex) -> Result<Vec<String>> {
+    let content = tokio::fs::read_to_string(file).await?;
+    Ok(re.captures_iter(&content).map(|m| m[1].to_owned()).collect())
+}
+
+async fn load_paths(file: impl AsRef<Path>, re: &Regex) -> Result<Vec<String>> {
+    let content = tokio::fs::read_to_string(file).await?;
+    Ok(re
+        .captures_iter(&content)
+        .flat_map(|m| m[1].split("::").map(String::from).collect::<Vec<_>>())
+        .collect())
+}
+
+#[tokio::test]
+#[allow(clippy::case_sensitive_file_extension_comparisons)]
+async fn all_symbols_are_used() -> Result<()> {
+    if option_env!("RUSTC_TEST_SUITE").is_some() {
+        return Ok(());
+    }
+
+    let used_re = &Regex::new(r"\bsym::(\w+)\b").unwrap();
+    let mut used_symbols_per_file = ["clippy_lints", "clippy_lints_internal", "clippy_utils", "src"]
+        .iter()
+        .flat_map(|dir| {
+            WalkDir::new(dir)
+                .into_iter()
+                .filter_entry(|e| e.file_name().to_str().is_some_and(|s| s.ends_with(".rs")) || e.file_type().is_dir())
+                .flat_map(|e| e.map(DirEntry::into_path))
+        })
+        .map(|file| load_symbols(file, used_re))
+        .collect::<FuturesUnordered<_>>();
+    let used_symbols = async {
+        let mut symbols = HashSet::default();
+        while let Some(syms) = used_symbols_per_file.next().await {
+            if let Ok(syms) = syms {
+                symbols.extend(syms);
+            }
+        }
+        symbols
+    };
+
+    let paths_re = Regex::new(r"path!\(([\w:]+)\)").unwrap();
+    let (interned, mut used, paths, paths_internal) = futures::join!(
+        load_interned_symbols(),
+        used_symbols,
+        load_paths("clippy_utils/src/paths.rs", &paths_re),
+        load_paths("clippy_lints_internal/src/internal_paths.rs", &paths_re),
+    );
+    used.extend(paths?);
+    used.extend(paths_internal?);
+    let interned = interned?;
+    let mut extra = interned.difference(&used).collect::<Vec<_>>();
+    if !extra.is_empty() {
+        extra.sort_unstable();
+        eprintln!("Unused symbols defined in {SYM_FILE}:");
+        for sym in extra {
+            eprintln!("  - {sym}");
+        }
+        Err(format!("extra symbols found — remove them {SYM_FILE}"))?;
+    }
+    Ok(())
+}