1 use clippy_utils::diagnostics::span_lint_and_then;
2 use clippy_utils::source::snippet;
3 use clippy_utils::{meets_msrv, msrvs};
4 use rustc_ast::ast::{Item, ItemKind, Ty, TyKind};
5 use rustc_errors::Applicability;
6 use rustc_lint::{EarlyContext, EarlyLintPass};
7 use rustc_semver::RustcVersion;
8 use rustc_session::{declare_tool_lint, impl_lint_pass};
10 declare_clippy_lint! {
12 /// Checks for constants and statics with an explicit `'static` lifetime.
14 /// ### Why is this bad?
15 /// Adding `'static` to every reference can create very
16 /// complicated types.
20 /// const FOO: &'static [(&'static str, &'static str, fn(&Bar) -> bool)] =
22 /// static FOO: &'static [(&'static str, &'static str, fn(&Bar) -> bool)] =
25 /// This code can be rewritten as
27 /// const FOO: &[(&str, &str, fn(&Bar) -> bool)] = &[...]
28 /// static FOO: &[(&str, &str, fn(&Bar) -> bool)] = &[...]
30 pub REDUNDANT_STATIC_LIFETIMES,
32 "Using explicit `'static` lifetime for constants or statics when elision rules would allow omitting them."
35 pub struct RedundantStaticLifetimes {
36 msrv: Option<RustcVersion>,
39 impl RedundantStaticLifetimes {
41 pub fn new(msrv: Option<RustcVersion>) -> Self {
46 impl_lint_pass!(RedundantStaticLifetimes => [REDUNDANT_STATIC_LIFETIMES]);
48 impl RedundantStaticLifetimes {
49 // Recursively visit types
50 fn visit_type(&mut self, ty: &Ty, cx: &EarlyContext<'_>, reason: &str) {
52 // Be careful of nested structures (arrays and tuples)
53 TyKind::Array(ref ty, _) => {
54 self.visit_type(&*ty, cx, reason);
56 TyKind::Tup(ref tup) => {
58 self.visit_type(&*tup_ty, cx, reason);
61 // This is what we are looking for !
62 TyKind::Rptr(ref optional_lifetime, ref borrow_type) => {
63 // Match the 'static lifetime
64 if let Some(lifetime) = *optional_lifetime {
65 match borrow_type.ty.kind {
66 TyKind::Path(..) | TyKind::Slice(..) | TyKind::Array(..) | TyKind::Tup(..) => {
67 if lifetime.ident.name == rustc_span::symbol::kw::StaticLifetime {
68 let snip = snippet(cx, borrow_type.ty.span, "<type>");
69 let sugg = format!("&{}", snip);
72 REDUNDANT_STATIC_LIFETIMES,
78 "consider removing `'static`",
80 Applicability::MachineApplicable, //snippet
89 self.visit_type(&*borrow_type.ty, cx, reason);
91 TyKind::Slice(ref ty) => {
92 self.visit_type(ty, cx, reason);
99 impl EarlyLintPass for RedundantStaticLifetimes {
100 fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
101 if !meets_msrv(self.msrv.as_ref(), &msrvs::STATIC_IN_CONST) {
105 if !item.span.from_expansion() {
106 if let ItemKind::Const(_, ref var_type, _) = item.kind {
107 self.visit_type(var_type, cx, "constants have by default a `'static` lifetime");
108 // Don't check associated consts because `'static` cannot be elided on those (issue
112 if let ItemKind::Static(ref var_type, _, _) = item.kind {
113 self.visit_type(var_type, cx, "statics have by default a `'static` lifetime");
118 extract_msrv_attr!(EarlyContext);