feat: adds redundant_test_prefix clippy lint

Closes rust-lang#8931.

Author: Caylub

CHANGELOG.md

@@ -5697,6 +5697,7 @@ Released 2018-09-13
 [`redundant_pub_crate`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pub_crate
 [`redundant_slicing`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_slicing
 [`redundant_static_lifetimes`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_static_lifetimes
+[`redundant_test_prefix`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_test_prefix
 [`redundant_type_annotations`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_type_annotations
 [`ref_as_ptr`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_as_ptr
 [`ref_binding_to_reference`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_binding_to_reference

clippy_dev/src/new_lint.rs

@@ -581,7 +581,7 @@ fn setup_mod_file(path: &Path, lint: &LintData<'_>) -> io::Result<&'static str>
 }
 
 #[test]
-fn test_camel_case() {
+fn camel_case() {
     let s = "a_lint";
     let s2 = to_camel_case(s);
     assert_eq!(s2, "ALint");

clippy_dev/src/update_lints.rs

@@ -1042,7 +1042,7 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_parse_contents() {
+    fn parse_contents() {
         static CONTENTS: &str = r#"
             declare_clippy_lint! {
                 #[clippy::version = "Hello Clippy!"]
@@ -1060,7 +1060,7 @@ mod tests {
             }
         "#;
         let mut result = Vec::new();
-        parse_contents(CONTENTS, "module_name", &mut result);
+        super::parse_contents(CONTENTS, "module_name", &mut result);
         for r in &mut result {
             r.declaration_range = Range::default();
         }
@@ -1085,7 +1085,7 @@ mod tests {
     }
 
     #[test]
-    fn test_parse_deprecated_contents() {
+    fn parse_deprecated_contents() {
         static DEPRECATED_CONTENTS: &str = r#"
             /// some doc comment
             declare_deprecated_lint! {
@@ -1096,7 +1096,7 @@ mod tests {
         "#;
 
         let mut result = Vec::new();
-        parse_deprecated_contents(DEPRECATED_CONTENTS, &mut result);
+        super::parse_deprecated_contents(DEPRECATED_CONTENTS, &mut result);
         for r in &mut result {
             r.declaration_range = Range::default();
         }
@@ -1110,7 +1110,7 @@ mod tests {
     }
 
     #[test]
-    fn test_usable_lints() {
+    fn usable_lints() {
         let lints = vec![
             Lint::new(
                 "should_assert_eq2",
@@ -1145,7 +1145,7 @@ mod tests {
     }
 
     #[test]
-    fn test_by_lint_group() {
+    fn by_lint_group() {
         let lints = vec![
             Lint::new("should_assert_eq", "group1", "\"abc\"", "module_name", Range::default()),
             Lint::new(
@@ -1179,7 +1179,7 @@ mod tests {
     }
 
     #[test]
-    fn test_gen_deprecated() {
+    fn gen_deprecated() {
         let lints = vec![
             DeprecatedLint::new(
                 "should_assert_eq",
@@ -1205,6 +1205,6 @@ mod tests {
             .join("\n")
             + "\n";
 
-        assert_eq!(expected, gen_deprecated(&lints));
+        assert_eq!(expected, super::gen_deprecated(&lints));
     }
 }

clippy_lints/src/cargo/feature_name.rs

@@ -80,7 +80,7 @@ fn lint(cx: &LateContext<'_>, feature: &str, substring: &str, is_prefix: bool) {
 }
 
 #[test]
-fn test_prefixes_sorted() {
+fn prefixes_sorted() {
     let mut sorted_prefixes = PREFIXES;
     sorted_prefixes.sort_unstable();
     assert_eq!(PREFIXES, sorted_prefixes);

clippy_lints/src/declared_lints.rs

@@ -624,6 +624,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::redundant_slicing::DEREF_BY_SLICING_INFO,
     crate::redundant_slicing::REDUNDANT_SLICING_INFO,
     crate::redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES_INFO,
+    crate::redundant_test_prefix::REDUNDANT_TEST_PREFIX_INFO,
     crate::redundant_type_annotations::REDUNDANT_TYPE_ANNOTATIONS_INFO,
     crate::ref_option_ref::REF_OPTION_REF_INFO,
     crate::ref_patterns::REF_PATTERNS_INFO,

clippy_lints/src/doc/mod.rs

@@ -223,7 +223,7 @@ declare_clippy_lint! {
     /// ///     assert_eq!(1_u8, 1);
     /// /// }
     /// /// ```
-    /// fn test_attr_in_doctest() {
+    /// fn attr_in_doctest() {
     ///     unimplemented!();
     /// }
     /// ```

clippy_lints/src/empty_with_brackets.rs

@@ -144,23 +144,22 @@ fn has_no_fields(cx: &EarlyContext<'_>, var_data: &VariantData, braces_span: Spa
 
 #[cfg(test)]
 mod unit_test {
-    use super::*;
 
     #[test]
-    fn test_has_no_ident_token() {
+    fn has_no_ident_token() {
         let input = "{ field: u8 }";
-        assert!(!has_no_ident_token(input));
+        assert!(!super::has_no_ident_token(input));
 
         let input = "(u8, String);";
-        assert!(!has_no_ident_token(input));
+        assert!(!super::has_no_ident_token(input));
 
         let input = " {
                 // test = 5
         }
         ";
-        assert!(has_no_ident_token(input));
+        assert!(super::has_no_ident_token(input));
 
         let input = " ();";
-        assert!(has_no_ident_token(input));
+        assert!(super::has_no_ident_token(input));
     }
 }

clippy_lints/src/lib.rs

@@ -301,6 +301,7 @@ mod redundant_locals;
 mod redundant_pub_crate;
 mod redundant_slicing;
 mod redundant_static_lifetimes;
+mod redundant_test_prefix;
 mod redundant_type_annotations;
 mod ref_option_ref;
 mod ref_patterns;
@@ -1165,6 +1166,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
             ..Default::default()
         })
     });
+    store.register_late_pass(|_| Box::new(redundant_test_prefix::RedundantTestPrefix));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 

clippy_lints/src/matches/overlapping_arms.rs

@@ -148,39 +148,44 @@ where
     None
 }
 
-#[test]
-fn test_overlapping() {
-    use rustc_span::DUMMY_SP;
-
-    let sp = |s, e| SpannedRange {
-        span: DUMMY_SP,
-        node: (s, e),
-    };
-
-    assert_eq!(None, overlapping::<u8>(&[]));
-    assert_eq!(None, overlapping(&[sp(1, EndBound::Included(4))]));
-    assert_eq!(
-        None,
-        overlapping(&[sp(1, EndBound::Included(4)), sp(5, EndBound::Included(6))])
-    );
-    assert_eq!(
-        None,
-        overlapping(&[
-            sp(1, EndBound::Included(4)),
-            sp(5, EndBound::Included(6)),
-            sp(10, EndBound::Included(11))
-        ],)
-    );
-    assert_eq!(
-        Some((&sp(1, EndBound::Included(4)), &sp(3, EndBound::Included(6)))),
-        overlapping(&[sp(1, EndBound::Included(4)), sp(3, EndBound::Included(6))])
-    );
-    assert_eq!(
-        Some((&sp(5, EndBound::Included(6)), &sp(6, EndBound::Included(11)))),
-        overlapping(&[
-            sp(1, EndBound::Included(4)),
-            sp(5, EndBound::Included(6)),
-            sp(6, EndBound::Included(11))
-        ],)
-    );
+#[cfg(test)]
+mod test {
+    use super::{EndBound, SpannedRange};
+
+    #[test]
+    fn overlapping() {
+        use rustc_span::DUMMY_SP;
+
+        let sp = |s, e| SpannedRange {
+            span: DUMMY_SP,
+            node: (s, e),
+        };
+
+        assert_eq!(None, super::overlapping::<u8>(&[]));
+        assert_eq!(None, super::overlapping(&[sp(1, EndBound::Included(4))]));
+        assert_eq!(
+            None,
+            super::overlapping(&[sp(1, EndBound::Included(4)), sp(5, EndBound::Included(6))])
+        );
+        assert_eq!(
+            None,
+            super::overlapping(&[
+                sp(1, EndBound::Included(4)),
+                sp(5, EndBound::Included(6)),
+                sp(10, EndBound::Included(11))
+            ],)
+        );
+        assert_eq!(
+            Some((&sp(1, EndBound::Included(4)), &sp(3, EndBound::Included(6)))),
+            super::overlapping(&[sp(1, EndBound::Included(4)), sp(3, EndBound::Included(6))])
+        );
+        assert_eq!(
+            Some((&sp(5, EndBound::Included(6)), &sp(6, EndBound::Included(11)))),
+            super::overlapping(&[
+                sp(1, EndBound::Included(4)),
+                sp(5, EndBound::Included(6)),
+                sp(6, EndBound::Included(11))
+            ],)
+        );
+    }
 }

clippy_lints/src/needless_continue.rs

@@ -440,11 +440,10 @@ fn span_of_first_expr_in_block(block: &ast::Block) -> Option<Span> {
 
 #[cfg(test)]
 mod test {
-    use super::erode_from_back;
 
     #[test]
     #[rustfmt::skip]
-    fn test_erode_from_back() {
+    fn erode_from_back() {
         let input = "\
 {
     let x = 5;
@@ -456,19 +455,19 @@ mod test {
     let x = 5;
     let y = format!(\"{}\", 42);";
 
-        let got = erode_from_back(input);
+        let got = super::erode_from_back(input);
         assert_eq!(expected, got);
     }
 
     #[test]
     #[rustfmt::skip]
-    fn test_erode_from_back_no_brace() {
+    fn erode_from_back_no_brace() {
         let input = "\
 let x = 5;
 let y = something();
 ";
         let expected = input;
-        let got = erode_from_back(input);
+        let got = super::erode_from_back(input);
         assert_eq!(expected, got);
     }
 }

clippy_lints/src/redundant_test_prefix.rs

@@ -0,0 +1,74 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::{is_in_cfg_test, is_in_test_function};
+use rustc_hir::intravisit::FnKind;
+use rustc_hir::{Body, FnDecl};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::declare_lint_pass;
+use rustc_span::def_id::LocalDefId;
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Triggers when a function annotated with the `#[test]` macro begins with `test_`
+    /// ### Why is this bad?
+    /// This is redundant, since the annotations already denotes the function a test.
+    /// Tests are executed using `cargo test `module::test-name-here::`.
+    /// It's clear that a test is a test, without prefixing `test_` to the test name.
+    /// ### Example
+    /// ```no_run
+    /// #[test]
+    /// fn my_test_case() {
+    ///     // test logic here...
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// #[test]
+    /// fn my_test_case() {
+    ///     // test logic here...
+    /// }
+    /// ```
+    #[clippy::version = "1.79.0"]
+    pub REDUNDANT_TEST_PREFIX,
+    pedantic,
+    "A test name is prefixed with `test`"
+}
+
+declare_lint_pass!(RedundantTestPrefix => [REDUNDANT_TEST_PREFIX]);
+
+impl LateLintPass<'_> for RedundantTestPrefix {
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'_>,
+        fn_kind: FnKind<'_>,
+        _: &FnDecl<'_>,
+        body: &Body<'_>,
+        span: Span,
+        _: LocalDefId,
+    ) {
+        if is_prefixed_with_test_fn(fn_kind)
+            && is_in_test_function(cx.tcx, body.id().hir_id)
+            && is_in_cfg_test(cx.tcx, body.id().hir_id)
+        {
+            span_lint_and_help(
+                cx,
+                REDUNDANT_TEST_PREFIX,
+                span,
+                "this test is prefixed redundantly with `test`",
+                None,
+                "consider removing the redundant `test` prefix from the test name",
+            );
+        }
+    }
+}
+
+fn is_prefixed_with_test_fn(fn_kind: FnKind<'_>) -> bool {
+    match fn_kind {
+        FnKind::ItemFn(ident, ..) => {
+            // check if `fn` name is prefixed with `test_`
+            ident.name.as_str().starts_with("test_")
+        },
+        // ignore closures
+        _ => false,
+    }
+}