Define the named_static_lifetimes lint

This lint will replace the existing hard-warning.

Replace the named static lifetime hard-warning with the new lint

Update the UI tests for the `named_static_lifetimes` lint

Remove the direct dependency on `rustc_lint_defs`

Author: jeremydavis519

compiler/rustc_hir_analysis/src/collect/lifetimes.rs

@@ -18,6 +18,7 @@ use rustc_middle::bug;
 use rustc_middle::hir::nested_filter;
 use rustc_middle::middle::resolve_lifetime::*;
 use rustc_middle::ty::{self, DefIdTree, TyCtxt, TypeSuperVisitable, TypeVisitor};
+use rustc_session::lint;
 use rustc_span::def_id::DefId;
 use rustc_span::symbol::{sym, Ident};
 use rustc_span::Span;
@@ -921,20 +922,24 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
                                     continue;
                                 }
                                 this.insert_lifetime(lt, Region::Static);
-                                this.tcx
-                                    .sess
-                                    .struct_span_warn(
-                                        lifetime.ident.span,
-                                        &format!(
+                                this.tcx.struct_span_lint_hir(
+                                    lint::builtin::NAMED_STATIC_LIFETIMES,
+                                    lifetime.hir_id,
+                                    lifetime.span,
+                                    |lint| {
+                                        let msg = &format!(
                                             "unnecessary lifetime parameter `{}`",
-                                            lifetime.ident,
-                                        ),
-                                    )
-                                    .help(&format!(
-                                        "you can use the `'static` lifetime directly, in place of `{}`",
-                                        lifetime.ident,
-                                    ))
-                                    .emit();
+                                            lifetime.name.ident(),
+                                        );
+                                        let help = &format!(
+                                            "you can use the `'static` lifetime directly, in place of `{}`",
+                                            lifetime.name.ident(),
+                                        );
+                                        lint.build(msg)
+                                            .help(help)
+                                            .emit();
+                                    },
+                                );
                             }
                         }
                     }

compiler/rustc_lint_defs/src/builtin.rs

@@ -1663,6 +1663,40 @@ declare_lint! {
     "detects lifetime parameters that are never used"
 }
 
+declare_lint! {
+    /// The `named_static_lifetimes` lint detects lifetime parameters that are
+    /// defined as outliving the static lifetime.
+    ///
+    /// ### Example
+    ///
+    /// ```rust,compile_fail
+    /// #[deny(named_static_lifetimes)]
+    ///
+    /// pub fn foo<'a>(_s: &'a str) where 'a: 'static {}
+    /// ```
+    ///
+    /// {{produces}}
+    ///
+    /// ### Explanation
+    ///
+    /// By definition, the static lifetime (`'static`) outlives every other
+    /// lifetime. If another lifetime `'a` lives at least as long as `'static`,
+    /// then it is identical to `'static`. In that case, there is no need for
+    /// the name `'a`, and it likely only makes the code harder to read.
+    ///
+    /// To fix this, consider using `'static` instead of the named lifetime.
+    /// Here is the result of doing that in the example above:
+    ///
+    /// ```rust
+    /// #[deny(named_static_lifetimes)]
+    ///
+    /// pub fn foo(_s: &'static str) {}
+    /// ```
+    pub NAMED_STATIC_LIFETIMES,
+    Warn,
+    "detects lifetime parameters that are identical to `'static`"
+}
+
 declare_lint! {
     /// The `tyvar_behind_raw_pointer` lint detects raw pointer to an
     /// inference variable.
@@ -3321,6 +3355,7 @@ declare_lint_pass! {
         UNCONDITIONAL_RECURSION,
         SINGLE_USE_LIFETIMES,
         UNUSED_LIFETIMES,
+        NAMED_STATIC_LIFETIMES,
         UNUSED_LABELS,
         TYVAR_BEHIND_RAW_POINTER,
         ELIDED_LIFETIMES_IN_PATHS,

tests/ui/generic-associated-types/unsatified-item-lifetime-bound.stderr

@@ -4,6 +4,7 @@ warning: unnecessary lifetime parameter `'a`
 LL |     type Y<'a: 'static>;
    |            ^^
    |
+   = note: `#[warn(named_static_lifetimes)]` on by default
    = help: you can use the `'static` lifetime directly, in place of `'a`
 
 error[E0478]: lifetime bound not satisfied

tests/ui/impl-trait/equal-hidden-lifetimes.stderr

@@ -4,6 +4,7 @@ warning: unnecessary lifetime parameter `'a`
 LL | fn equal_regions_static<'a: 'static>(x: &'a i32) -> impl Sized {
    |                         ^^
    |
+   = note: `#[warn(named_static_lifetimes)]` on by default
    = help: you can use the `'static` lifetime directly, in place of `'a`
 
 warning: 1 warning emitted

tests/ui/issues/issue-30438-c.stderr

@@ -4,6 +4,7 @@ warning: unnecessary lifetime parameter `'z`
 LL | fn silly<'y, 'z>(_s: &'y Test<'z>) -> &'y <Test<'z> as Trait>::Out where 'z: 'static {
    |                                                                          ^^
    |
+   = note: `#[warn(named_static_lifetimes)]` on by default
    = help: you can use the `'static` lifetime directly, in place of `'z`
 
 error[E0515]: cannot return reference to local variable `x`

tests/ui/regions/regions-free-region-outlives-static-outlives-free-region.stderr

@@ -4,6 +4,7 @@ warning: unnecessary lifetime parameter `'a`
 LL |     where 'a: 'static
    |           ^^
    |
+   = note: `#[warn(named_static_lifetimes)]` on by default
    = help: you can use the `'static` lifetime directly, in place of `'a`
 
 warning: 1 warning emitted

tests/ui/regions/regions-static-bound-rpass.stderr

@@ -4,6 +4,7 @@ warning: unnecessary lifetime parameter `'a`
 LL |     where 'a: 'static { t }
    |           ^^
    |
+   = note: `#[warn(named_static_lifetimes)]` on by default
    = help: you can use the `'static` lifetime directly, in place of `'a`
 
 warning: unnecessary lifetime parameter `'a`

tests/ui/regions/regions-static-bound.stderr

@@ -4,6 +4,7 @@ warning: unnecessary lifetime parameter `'a`
 LL |     where 'a: 'static { t }
    |           ^^
    |
+   = note: `#[warn(named_static_lifetimes)]` on by default
    = help: you can use the `'static` lifetime directly, in place of `'a`
 
 warning: unnecessary lifetime parameter `'b`

tests/ui/static/static-lifetime-bound.stderr

@@ -4,6 +4,7 @@ warning: unnecessary lifetime parameter `'a`
 LL | fn f<'a: 'static>(_: &'a i32) {}
    |      ^^
    |
+   = note: `#[warn(named_static_lifetimes)]` on by default
    = help: you can use the `'static` lifetime directly, in place of `'a`
 
 error[E0597]: `x` does not live long enough

tests/ui/type-alias-impl-trait/bounds-are-checked.stderr

@@ -4,6 +4,7 @@ warning: unnecessary lifetime parameter `'a`
 LL | fn f<'a: 'static>(t: &'a str) -> X<'a> {
    |      ^^
    |
+   = note: `#[warn(named_static_lifetimes)]` on by default
    = help: you can use the `'static` lifetime directly, in place of `'a`
 
 error: non-defining opaque type use in defining scope