Add disabled-in-tests configuration

Author: smoelius

clippy_config/src/conf.rs

@@ -578,6 +578,8 @@ define_Conf! {
     /// Use the Cognitive Complexity lint instead.
     #[conf_deprecated("Please use `cognitive-complexity-threshold` instead", cognitive_complexity_threshold)]
     cyclomatic_complexity_threshold: u64 = 25,
+    /// Lints to disable in tests.
+    disabled_in_tests: Vec<String> = Vec::new(),
     /// The list of disallowed macros, written as fully qualified paths.
     ///
     /// **Fields:**

clippy_utils/src/diagnostics.rs

@@ -8,13 +8,31 @@
 //! Thank you!
 //! ~The `INTERNAL_METADATA_COLLECTOR` lint
 
+use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::{Applicability, Diag, DiagMessage, MultiSpan, SubdiagMessage};
 #[cfg(debug_assertions)]
 use rustc_errors::{EmissionGuarantee, SubstitutionPart, Suggestions};
 use rustc_hir::HirId;
 use rustc_lint::{LateContext, Lint, LintContext};
 use rustc_span::Span;
 use std::env;
+use std::sync::OnceLock;
+
+pub static DISABLED: OnceLock<FxHashSet<&'static str>> = OnceLock::new();
+
+#[allow(clippy::implicit_hasher)]
+pub fn set_disabled(disabled: FxHashSet<&'static str>) {
+    DISABLED
+        .set(disabled)
+        .unwrap_or_else(|_| panic!("`set_disabled` was already called"));
+}
+
+fn is_disabled(lint: &Lint) -> bool {
+    DISABLED.get().is_some_and(|disabled| {
+        let name = lint.name_lower();
+        disabled.contains(name.strip_prefix("clippy::").unwrap_or(&name))
+    })
+}
 
 fn docs_link(diag: &mut Diag<'_, ()>, lint: &'static Lint) {
     if env::var("CLIPPY_DISABLE_DOCS_LINKS").is_err()
@@ -104,6 +122,9 @@ fn validate_diag(diag: &Diag<'_, impl EmissionGuarantee>) {
 /// ```
 #[track_caller]
 pub fn span_lint<T: LintContext>(cx: &T, lint: &'static Lint, sp: impl Into<MultiSpan>, msg: impl Into<DiagMessage>) {
+    if is_disabled(lint) {
+        return;
+    }
     #[expect(clippy::disallowed_methods)]
     cx.span_lint(lint, sp, |diag| {
         diag.primary_message(msg);
@@ -157,6 +178,9 @@ pub fn span_lint_and_help<T: LintContext>(
     help_span: Option<Span>,
     help: impl Into<SubdiagMessage>,
 ) {
+    if is_disabled(lint) {
+        return;
+    }
     #[expect(clippy::disallowed_methods)]
     cx.span_lint(lint, span, |diag| {
         diag.primary_message(msg);
@@ -218,6 +242,9 @@ pub fn span_lint_and_note<T: LintContext>(
     note_span: Option<Span>,
     note: impl Into<SubdiagMessage>,
 ) {
+    if is_disabled(lint) {
+        return;
+    }
     #[expect(clippy::disallowed_methods)]
     cx.span_lint(lint, span, |diag| {
         diag.primary_message(msg);
@@ -259,6 +286,9 @@ where
     M: Into<DiagMessage>,
     F: FnOnce(&mut Diag<'_, ()>),
 {
+    if is_disabled(lint) {
+        return;
+    }
     #[expect(clippy::disallowed_methods)]
     cx.span_lint(lint, sp, |diag| {
         diag.primary_message(msg);
@@ -296,6 +326,9 @@ where
 /// the `#[allow]` will work.
 #[track_caller]
 pub fn span_lint_hir(cx: &LateContext<'_>, lint: &'static Lint, hir_id: HirId, sp: Span, msg: impl Into<DiagMessage>) {
+    if is_disabled(lint) {
+        return;
+    }
     #[expect(clippy::disallowed_methods)]
     cx.tcx.node_span_lint(lint, hir_id, sp, |diag| {
         diag.primary_message(msg);
@@ -339,6 +372,9 @@ pub fn span_lint_hir_and_then(
     msg: impl Into<DiagMessage>,
     f: impl FnOnce(&mut Diag<'_, ()>),
 ) {
+    if is_disabled(lint) {
+        return;
+    }
     #[expect(clippy::disallowed_methods)]
     cx.tcx.node_span_lint(lint, hir_id, sp, |diag| {
         diag.primary_message(msg);

src/driver.rs

@@ -8,6 +8,7 @@
 
 // FIXME: switch to something more ergonomic here, once available.
 // (Currently there is no way to opt into sysroot crates without `extern crate`.)
+extern crate rustc_data_structures;
 extern crate rustc_driver;
 extern crate rustc_interface;
 extern crate rustc_session;
@@ -18,15 +19,18 @@ extern crate rustc_span;
 #[cfg(feature = "jemalloc")]
 extern crate tikv_jemalloc_sys as jemalloc_sys;
 
+use clippy_config::Conf;
 use clippy_utils::sym;
 use declare_clippy_lint::LintListBuilder;
+use rustc_data_structures::fx::FxHashSet;
 use rustc_interface::interface;
-use rustc_session::EarlyDiagCtxt;
 use rustc_session::config::ErrorOutputType;
 use rustc_session::parse::ParseSess;
+use rustc_session::{EarlyDiagCtxt, Session};
 use rustc_span::symbol::Symbol;
 
 use std::env;
+use std::fmt::Write;
 use std::fs::read_to_string;
 use std::path::Path;
 use std::process::exit;
@@ -130,6 +134,7 @@ impl rustc_driver::Callbacks for RustcCallbacks {
 
 struct ClippyCallbacks {
     clippy_args_var: Option<String>,
+    testing: bool,
 }
 
 impl rustc_driver::Callbacks for ClippyCallbacks {
@@ -138,6 +143,7 @@ impl rustc_driver::Callbacks for ClippyCallbacks {
         let conf_path = clippy_config::lookup_conf_file();
         let previous = config.register_lints.take();
         let clippy_args_var = self.clippy_args_var.take();
+        let testing = self.testing;
         config.psess_created = Some(Box::new(move |psess| {
             track_clippy_args(psess, clippy_args_var.as_deref());
             track_files(psess);
@@ -156,11 +162,14 @@ impl rustc_driver::Callbacks for ClippyCallbacks {
                 (previous)(sess, lint_store);
             }
 
+            let conf = clippy_config::Conf::read(sess, &conf_path);
+            let disabled = build_disabled_set(sess, conf, testing);
+            clippy_utils::diagnostics::set_disabled(disabled);
+
             let mut list_builder = LintListBuilder::default();
             list_builder.insert(clippy_lints::declared_lints::LINTS);
             list_builder.register(lint_store);
 
-            let conf = clippy_config::Conf::read(sess, &conf_path);
             clippy_lints::register_lint_passes(lint_store, conf);
 
             #[cfg(feature = "internal")]
@@ -181,6 +190,34 @@ impl rustc_driver::Callbacks for ClippyCallbacks {
     }
 }
 
+fn build_disabled_set(sess: &Session, conf: &'static Conf, testing: bool) -> FxHashSet<&'static str> {
+    if !testing {
+        return FxHashSet::default();
+    }
+    let disabled = conf
+        .disabled_in_tests
+        .iter()
+        .map(String::as_str)
+        .collect::<FxHashSet<_>>();
+    let declared_lint_names = clippy_lints::declared_lints::LINTS
+        .iter()
+        .map(|lint| lint.name_lower())
+        .collect::<FxHashSet<_>>();
+    #[allow(rustc::potential_query_instability)]
+    for &name in &disabled {
+        if !declared_lint_names.contains(name) {
+            let mut msg = format!("unknown lint `{name}`");
+            let replaced = name.replace('-', "_");
+            if declared_lint_names.contains(&replaced) {
+                writeln!(msg, ". Did you mean `{replaced}`?").unwrap();
+            }
+            sess.dcx().warn(msg);
+        }
+    }
+    disabled
+}
+
+#[allow(clippy::ignored_unit_patterns)]
 fn display_help() {
     println!("{}", help_message());
 }
@@ -333,7 +370,13 @@ pub fn main() {
         let clippy_enabled = !cap_lints_allow && relevant_package && !info_query;
         if clippy_enabled {
             args.extend(clippy_args);
-            rustc_driver::run_compiler(&args, &mut ClippyCallbacks { clippy_args_var });
+            rustc_driver::run_compiler(
+                &args,
+                &mut ClippyCallbacks {
+                    clippy_args_var,
+                    testing: orig_args.iter().any(|arg| arg == "--test"),
+                },
+            );
         } else {
             rustc_driver::run_compiler(&args, &mut RustcCallbacks { clippy_args_var });
         }

tests/ui-toml/disabled_in_tests_typo/clippy.toml

@@ -0,0 +1 @@
+disabled-in-tests = ["unwrap-used"]

tests/ui-toml/disabled_in_tests_typo/typo.rs

@@ -0,0 +1,4 @@
+//@check-pass
+//@compile-flags: --test
+
+fn main() {}

tests/ui-toml/disabled_in_tests_typo/typo.stderr

@@ -0,0 +1,4 @@
+warning: unknown lint `unwrap-used`. Did you mean `unwrap_used`?
+
+warning: 1 warning emitted
+

tests/ui-toml/disabled_in_tests_unwrap_used/clippy.toml

@@ -0,0 +1 @@
+disabled-in-tests = ["unwrap_used"]

tests/ui-toml/disabled_in_tests_unwrap_used/unwrap_used

@@ -0,0 +1,34 @@
+//@compile-flags: --test
+
+#![warn(clippy::unwrap_used)]
+#![warn(clippy::get_unwrap)]
+
+fn main() {}
+
+#[test]
+fn test() {
+    let boxed_slice: Box<[u8]> = Box::new([0, 1, 2, 3]);
+    let _ = &boxed_slice[1];
+    //~^ get_unwrap
+}
+
+#[cfg(test)]
+mod issue9612 {
+    // should not lint in `#[cfg(test)]` modules
+    #[test]
+    fn test_fn() {
+        let _a: u8 = 2.try_into().unwrap();
+        let _a: u8 = 3.try_into().expect("");
+
+        util();
+    }
+
+    #[allow(unconditional_panic)]
+    fn util() {
+        let _a: u8 = 4.try_into().unwrap();
+        let _a: u8 = 5.try_into().expect("");
+        // should still warn
+        let _ = &Box::new([0])[1];
+        //~^ get_unwrap
+    }
+}

tests/ui-toml/disabled_in_tests_unwrap_used/unwrap_used.fixed

@@ -0,0 +1,34 @@
+//@compile-flags: --test
+
+#![warn(clippy::unwrap_used)]
+#![warn(clippy::get_unwrap)]
+
+fn main() {}
+
+#[test]
+fn test() {
+    let boxed_slice: Box<[u8]> = Box::new([0, 1, 2, 3]);
+    let _ = boxed_slice.get(1).unwrap();
+    //~^ get_unwrap
+}
+
+#[cfg(test)]
+mod issue9612 {
+    // should not lint in `#[cfg(test)]` modules
+    #[test]
+    fn test_fn() {
+        let _a: u8 = 2.try_into().unwrap();
+        let _a: u8 = 3.try_into().expect("");
+
+        util();
+    }
+
+    #[allow(unconditional_panic)]
+    fn util() {
+        let _a: u8 = 4.try_into().unwrap();
+        let _a: u8 = 5.try_into().expect("");
+        // should still warn
+        let _ = Box::new([0]).get(1).unwrap();
+        //~^ get_unwrap
+    }
+}