X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=clippy_lints%2Fsrc%2Fattrs.rs;h=45250e1eca629cec41924c74935a9a97f471adf0;hb=6feed2713c7740eb5868eba43745bc508b8b77aa;hp=58af069f1d9e8cd9e53a2bcf436d7b1eb2aa5b32;hpb=87ec0580f9a5268cbe8a61dbde6492d7c1e364ab;p=rust.git diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs index 58af069f1d9..45250e1eca6 100644 --- a/clippy_lints/src/attrs.rs +++ b/clippy_lints/src/attrs.rs @@ -1,237 +1,221 @@ -// Copyright 2014-2018 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - - //! checks for attributes use crate::reexport::*; use crate::utils::{ - in_macro, last_line_of_span, match_def_path, opt_def_id, paths, snippet_opt, span_lint, span_lint_and_sugg, - span_lint_and_then, without_block_comments, + in_macro, last_line_of_span, paths, snippet_opt, span_lint, span_lint_and_sugg, span_lint_and_then, + without_block_comments, }; use if_chain::if_chain; -use crate::rustc::hir::*; -use crate::rustc::lint::{ - CheckLintNameResult, EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintArray, LintContext, LintPass, +use rustc::hir::*; +use rustc::lint::{ + in_external_macro, CheckLintNameResult, EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintArray, + LintContext, LintPass, }; -use crate::rustc::ty::{self, TyCtxt}; -use crate::rustc::{declare_tool_lint, lint_array}; +use rustc::ty; +use rustc::{declare_lint_pass, declare_tool_lint}; +use rustc_errors::Applicability; use semver::Version; -use crate::syntax::ast::{ - AttrStyle, Attribute, Lit, LitKind, MetaItemKind, NestedMetaItem, NestedMetaItemKind, -}; -use crate::syntax::source_map::Span; -use crate::rustc_errors::Applicability; +use syntax::ast::{AttrStyle, Attribute, Lit, LitKind, MetaItemKind, NestedMetaItem}; +use syntax::source_map::Span; -/// **What it does:** Checks for items annotated with `#[inline(always)]`, -/// unless the annotated function is empty or simply panics. -/// -/// **Why is this bad?** While there are valid uses of this annotation (and once -/// you know when to use it, by all means `allow` this lint), it's a common -/// newbie-mistake to pepper one's code with it. -/// -/// As a rule of thumb, before slapping `#[inline(always)]` on a function, -/// measure if that additional function call really affects your runtime profile -/// sufficiently to make up for the increase in compile time. -/// -/// **Known problems:** False positives, big time. This lint is meant to be -/// deactivated by everyone doing serious performance work. This means having -/// done the measurement. -/// -/// **Example:** -/// ```rust -/// #[inline(always)] -/// fn not_quite_hot_code(..) { ... } -/// ``` declare_clippy_lint! { + /// **What it does:** Checks for items annotated with `#[inline(always)]`, + /// unless the annotated function is empty or simply panics. + /// + /// **Why is this bad?** While there are valid uses of this annotation (and once + /// you know when to use it, by all means `allow` this lint), it's a common + /// newbie-mistake to pepper one's code with it. + /// + /// As a rule of thumb, before slapping `#[inline(always)]` on a function, + /// measure if that additional function call really affects your runtime profile + /// sufficiently to make up for the increase in compile time. + /// + /// **Known problems:** False positives, big time. This lint is meant to be + /// deactivated by everyone doing serious performance work. This means having + /// done the measurement. + /// + /// **Example:** + /// ```ignore + /// #[inline(always)] + /// fn not_quite_hot_code(..) { ... } + /// ``` pub INLINE_ALWAYS, pedantic, "use of `#[inline(always)]`" } -/// **What it does:** Checks for `extern crate` and `use` items annotated with -/// lint attributes. -/// -/// This lint whitelists `#[allow(unused_imports)]` and `#[allow(deprecated)]` on -/// `use` items and `#[allow(unused_imports)]` on `extern crate` items with a -/// `#[macro_use]` attribute. -/// -/// **Why is this bad?** Lint attributes have no effect on crate imports. Most -/// likely a `!` was forgotten. -/// -/// **Known problems:** None. -/// -/// **Example:** -/// ```rust -/// // Bad -/// #[deny(dead_code)] -/// extern crate foo; -/// #[forbid(dead_code)] -/// use foo::bar; -/// -/// // Ok -/// #[allow(unused_imports)] -/// use foo::baz; -/// #[allow(unused_imports)] -/// #[macro_use] -/// extern crate baz; -/// ``` declare_clippy_lint! { + /// **What it does:** Checks for `extern crate` and `use` items annotated with + /// lint attributes. + /// + /// This lint whitelists `#[allow(unused_imports)]` and `#[allow(deprecated)]` on + /// `use` items and `#[allow(unused_imports)]` on `extern crate` items with a + /// `#[macro_use]` attribute. + /// + /// **Why is this bad?** Lint attributes have no effect on crate imports. Most + /// likely a `!` was forgotten. + /// + /// **Known problems:** None. + /// + /// **Example:** + /// ```ignore + /// // Bad + /// #[deny(dead_code)] + /// extern crate foo; + /// #[forbid(dead_code)] + /// use foo::bar; + /// + /// // Ok + /// #[allow(unused_imports)] + /// use foo::baz; + /// #[allow(unused_imports)] + /// #[macro_use] + /// extern crate baz; + /// ``` pub USELESS_ATTRIBUTE, correctness, "use of lint attributes on `extern crate` items" } -/// **What it does:** Checks for `#[deprecated]` annotations with a `since` -/// field that is not a valid semantic version. -/// -/// **Why is this bad?** For checking the version of the deprecation, it must be -/// a valid semver. Failing that, the contained information is useless. -/// -/// **Known problems:** None. -/// -/// **Example:** -/// ```rust -/// #[deprecated(since = "forever")] -/// fn something_else(..) { ... } -/// ``` declare_clippy_lint! { + /// **What it does:** Checks for `#[deprecated]` annotations with a `since` + /// field that is not a valid semantic version. + /// + /// **Why is this bad?** For checking the version of the deprecation, it must be + /// a valid semver. Failing that, the contained information is useless. + /// + /// **Known problems:** None. + /// + /// **Example:** + /// ```rust + /// #[deprecated(since = "forever")] + /// fn something_else() { /* ... */ } + /// ``` pub DEPRECATED_SEMVER, correctness, "use of `#[deprecated(since = \"x\")]` where x is not semver" } -/// **What it does:** Checks for empty lines after outer attributes -/// -/// **Why is this bad?** -/// Most likely the attribute was meant to be an inner attribute using a '!'. -/// If it was meant to be an outer attribute, then the following item -/// should not be separated by empty lines. -/// -/// **Known problems:** Can cause false positives. -/// -/// From the clippy side it's difficult to detect empty lines between an attributes and the -/// following item because empty lines and comments are not part of the AST. The parsing -/// currently works for basic cases but is not perfect. -/// -/// **Example:** -/// ```rust -/// // Bad -/// #[inline(always)] -/// -/// fn not_quite_good_code(..) { ... } -/// -/// // Good (as inner attribute) -/// #![inline(always)] -/// -/// fn this_is_fine(..) { ... } -/// -/// // Good (as outer attribute) -/// #[inline(always)] -/// fn this_is_fine_too(..) { ... } -/// ``` declare_clippy_lint! { + /// **What it does:** Checks for empty lines after outer attributes + /// + /// **Why is this bad?** + /// Most likely the attribute was meant to be an inner attribute using a '!'. + /// If it was meant to be an outer attribute, then the following item + /// should not be separated by empty lines. + /// + /// **Known problems:** Can cause false positives. + /// + /// From the clippy side it's difficult to detect empty lines between an attributes and the + /// following item because empty lines and comments are not part of the AST. The parsing + /// currently works for basic cases but is not perfect. + /// + /// **Example:** + /// ```rust + /// // Bad + /// #[inline(always)] + /// + /// fn not_quite_good_code(..) { ... } + /// + /// // Good (as inner attribute) + /// #![inline(always)] + /// + /// fn this_is_fine(..) { ... } + /// + /// // Good (as outer attribute) + /// #[inline(always)] + /// fn this_is_fine_too(..) { ... } + /// ``` pub EMPTY_LINE_AFTER_OUTER_ATTR, nursery, "empty line after outer attribute" } -/// **What it does:** Checks for `allow`/`warn`/`deny`/`forbid` attributes with scoped clippy -/// lints and if those lints exist in clippy. If there is a uppercase letter in the lint name -/// (not the tool name) and a lowercase version of this lint exists, it will suggest to lowercase -/// the lint name. -/// -/// **Why is this bad?** A lint attribute with a mistyped lint name won't have an effect. -/// -/// **Known problems:** None. -/// -/// **Example:** -/// Bad: -/// ```rust -/// #![warn(if_not_els)] -/// #![deny(clippy::All)] -/// ``` -/// -/// Good: -/// ```rust -/// #![warn(if_not_else)] -/// #![deny(clippy::all)] -/// ``` declare_clippy_lint! { + /// **What it does:** Checks for `allow`/`warn`/`deny`/`forbid` attributes with scoped clippy + /// lints and if those lints exist in clippy. If there is a uppercase letter in the lint name + /// (not the tool name) and a lowercase version of this lint exists, it will suggest to lowercase + /// the lint name. + /// + /// **Why is this bad?** A lint attribute with a mistyped lint name won't have an effect. + /// + /// **Known problems:** None. + /// + /// **Example:** + /// Bad: + /// ```rust + /// #![warn(if_not_els)] + /// #![deny(clippy::All)] + /// ``` + /// + /// Good: + /// ```rust + /// #![warn(if_not_else)] + /// #![deny(clippy::all)] + /// ``` pub UNKNOWN_CLIPPY_LINTS, style, "unknown_lints for scoped Clippy lints" } -/// **What it does:** Checks for `#[cfg_attr(rustfmt, rustfmt_skip)]` and suggests to replace it -/// with `#[rustfmt::skip]`. -/// -/// **Why is this bad?** Since tool_attributes ([rust-lang/rust#44690](https://github.com/rust-lang/rust/issues/44690)) -/// are stable now, they should be used instead of the old `cfg_attr(rustfmt)` attributes. -/// -/// **Known problems:** This lint doesn't detect crate level inner attributes, because they get -/// processed before the PreExpansionPass lints get executed. See -/// [#3123](https://github.com/rust-lang/rust-clippy/pull/3123#issuecomment-422321765) -/// -/// **Example:** -/// -/// Bad: -/// ```rust -/// #[cfg_attr(rustfmt, rustfmt_skip)] -/// fn main() { } -/// ``` -/// -/// Good: -/// ```rust -/// #[rustfmt::skip] -/// fn main() { } -/// ``` declare_clippy_lint! { + /// **What it does:** Checks for `#[cfg_attr(rustfmt, rustfmt_skip)]` and suggests to replace it + /// with `#[rustfmt::skip]`. + /// + /// **Why is this bad?** Since tool_attributes ([rust-lang/rust#44690](https://github.com/rust-lang/rust/issues/44690)) + /// are stable now, they should be used instead of the old `cfg_attr(rustfmt)` attributes. + /// + /// **Known problems:** This lint doesn't detect crate level inner attributes, because they get + /// processed before the PreExpansionPass lints get executed. See + /// [#3123](https://github.com/rust-lang/rust-clippy/pull/3123#issuecomment-422321765) + /// + /// **Example:** + /// + /// Bad: + /// ```rust + /// #[cfg_attr(rustfmt, rustfmt_skip)] + /// fn main() { } + /// ``` + /// + /// Good: + /// ```rust + /// #[rustfmt::skip] + /// fn main() { } + /// ``` pub DEPRECATED_CFG_ATTR, complexity, "usage of `cfg_attr(rustfmt)` instead of `tool_attributes`" } -#[derive(Copy, Clone)] -pub struct AttrPass; +declare_lint_pass!(Attributes => [ + INLINE_ALWAYS, + DEPRECATED_SEMVER, + USELESS_ATTRIBUTE, + EMPTY_LINE_AFTER_OUTER_ATTR, + UNKNOWN_CLIPPY_LINTS, +]); -impl LintPass for AttrPass { - fn get_lints(&self) -> LintArray { - lint_array!( - INLINE_ALWAYS, - DEPRECATED_SEMVER, - USELESS_ATTRIBUTE, - EMPTY_LINE_AFTER_OUTER_ATTR, - UNKNOWN_CLIPPY_LINTS, - ) - } -} - -impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AttrPass { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Attributes { fn check_attribute(&mut self, cx: &LateContext<'a, 'tcx>, attr: &'tcx Attribute) { - if let Some(ref items) = attr.meta_item_list() { - match &*attr.name().as_str() { - "allow" | "warn" | "deny" | "forbid" => { - check_clippy_lint_names(cx, items); + if let Some(items) = &attr.meta_item_list() { + if let Some(ident) = attr.ident() { + match &*ident.as_str() { + "allow" | "warn" | "deny" | "forbid" => { + check_clippy_lint_names(cx, items); + }, + _ => {}, } - _ => {} - } - if items.is_empty() || attr.name() != "deprecated" { - return; - } - for item in items { - if_chain! { - if let NestedMetaItemKind::MetaItem(ref mi) = item.node; - if let MetaItemKind::NameValue(ref lit) = mi.node; - if mi.name() == "since"; - then { - check_semver(cx, item.span, lit); + if items.is_empty() || !attr.check_name("deprecated") { + return; + } + for item in items { + if_chain! { + if let NestedMetaItem::MetaItem(mi) = &item; + if let MetaItemKind::NameValue(lit) = &mi.node; + if mi.check_name("since"); + then { + check_semver(cx, item.span(), lit); + } } } } @@ -239,60 +223,65 @@ fn check_attribute(&mut self, cx: &LateContext<'a, 'tcx>, attr: &'tcx Attribute) } fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { - if is_relevant_item(cx.tcx, item) { - check_attrs(cx, item.span, item.name, &item.attrs) + if is_relevant_item(cx, item) { + check_attrs(cx, item.span, item.ident.name, &item.attrs) } match item.node { ItemKind::ExternCrate(..) | ItemKind::Use(..) => { - let skip_unused_imports = item.attrs.iter().any(|attr| attr.name() == "macro_use"); + let skip_unused_imports = item.attrs.iter().any(|attr| attr.check_name("macro_use")); for attr in &item.attrs { - if let Some(ref lint_list) = attr.meta_item_list() { - match &*attr.name().as_str() { - "allow" | "warn" | "deny" | "forbid" => { - // whitelist `unused_imports` and `deprecated` for `use` items - // and `unused_imports` for `extern crate` items with `macro_use` - for lint in lint_list { - match item.node { - ItemKind::Use(..) => if is_word(lint, "unused_imports") - || is_word(lint, "deprecated") { - return - }, - ItemKind::ExternCrate(..) => { - if is_word(lint, "unused_imports") - && skip_unused_imports { - return - } - if is_word(lint, "unused_extern_crates") { - return - } + if in_external_macro(cx.sess(), attr.span) { + return; + } + if let Some(lint_list) = &attr.meta_item_list() { + if let Some(ident) = attr.ident() { + match &*ident.as_str() { + "allow" | "warn" | "deny" | "forbid" => { + // whitelist `unused_imports` and `deprecated` for `use` items + // and `unused_imports` for `extern crate` items with `macro_use` + for lint in lint_list { + match item.node { + ItemKind::Use(..) => { + if is_word(lint, "unused_imports") || is_word(lint, "deprecated") { + return; + } + }, + ItemKind::ExternCrate(..) => { + if is_word(lint, "unused_imports") && skip_unused_imports { + return; + } + if is_word(lint, "unused_extern_crates") { + return; + } + }, + _ => {}, } - _ => {}, } - } - let line_span = last_line_of_span(cx, attr.span); - - if let Some(mut sugg) = snippet_opt(cx, line_span) { - if sugg.contains("#[") { - span_lint_and_then( - cx, - USELESS_ATTRIBUTE, - line_span, - "useless lint attribute", - |db| { - sugg = sugg.replacen("#[", "#![", 1); - db.span_suggestion_with_applicability( - line_span, - "if you just forgot a `!`, use", - sugg, - Applicability::MachineApplicable, - ); - }, - ); + let line_span = last_line_of_span(cx, attr.span); + + if let Some(mut sugg) = snippet_opt(cx, line_span) { + if sugg.contains("#[") { + span_lint_and_then( + cx, + USELESS_ATTRIBUTE, + line_span, + "useless lint attribute", + |db| { + sugg = sugg.replacen("#[", "#![", 1); + db.span_suggestion( + line_span, + "if you just forgot a `!`, use", + sugg, + Applicability::MachineApplicable, + ); + }, + ); + } } - } - }, - _ => {}, + }, + _ => {}, + } } } } @@ -302,13 +291,13 @@ fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { } fn check_impl_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx ImplItem) { - if is_relevant_impl(cx.tcx, item) { + if is_relevant_impl(cx, item) { check_attrs(cx, item.span, item.ident.name, &item.attrs) } } fn check_trait_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx TraitItem) { - if is_relevant_trait(cx.tcx, item) { + if is_relevant_trait(cx, item) { check_attrs(cx, item.span, item.ident.name, &item.attrs) } } @@ -319,10 +308,11 @@ fn check_clippy_lint_names(cx: &LateContext<'_, '_>, items: &[NestedMetaItem]) { let lint_store = cx.lints(); for lint in items { if_chain! { - if let Some(word) = lint.word(); - if let Some(tool_name) = word.is_scoped(); + if let Some(meta_item) = lint.meta_item(); + if meta_item.path.segments.len() > 1; + if let tool_name = meta_item.path.segments[0].ident; if tool_name.as_str() == "clippy"; - let name = word.name(); + let name = meta_item.path.segments.last().unwrap().ident.name; if let CheckLintNameResult::Tool(Err((None, _))) = lint_store.check_lint_name( &name.as_str(), Some(tool_name.as_str()), @@ -331,20 +321,25 @@ fn check_clippy_lint_names(cx: &LateContext<'_, '_>, items: &[NestedMetaItem]) { span_lint_and_then( cx, UNKNOWN_CLIPPY_LINTS, - lint.span, + lint.span(), &format!("unknown clippy lint: clippy::{}", name), |db| { - if name.as_str().chars().any(|c| c.is_uppercase()) { - let name_lower = name.as_str().to_lowercase().to_string(); + if name.as_str().chars().any(char::is_uppercase) { + let name_lower = name.as_str().to_lowercase(); match lint_store.check_lint_name( &name_lower, Some(tool_name.as_str()) ) { - CheckLintNameResult::NoLint => (), + // FIXME: can we suggest similar lint names here? + // https://github.com/rust-lang/rust/pull/56992 + CheckLintNameResult::NoLint(None) => (), _ => { - db.span_suggestion(lint.span, - "lowercase the lint name", - name_lower); + db.span_suggestion( + lint.span(), + "lowercase the lint name", + name_lower, + Applicability::MaybeIncorrect, + ); } } } @@ -355,55 +350,58 @@ fn check_clippy_lint_names(cx: &LateContext<'_, '_>, items: &[NestedMetaItem]) { } } -fn is_relevant_item(tcx: TyCtxt<'_, '_, '_>, item: &Item) -> bool { +fn is_relevant_item(cx: &LateContext<'_, '_>, item: &Item) -> bool { if let ItemKind::Fn(_, _, _, eid) = item.node { - is_relevant_expr(tcx, tcx.body_tables(eid), &tcx.hir.body(eid).value) + is_relevant_expr(cx, cx.tcx.body_tables(eid), &cx.tcx.hir().body(eid).value) } else { true } } -fn is_relevant_impl(tcx: TyCtxt<'_, '_, '_>, item: &ImplItem) -> bool { +fn is_relevant_impl(cx: &LateContext<'_, '_>, item: &ImplItem) -> bool { match item.node { - ImplItemKind::Method(_, eid) => is_relevant_expr(tcx, tcx.body_tables(eid), &tcx.hir.body(eid).value), + ImplItemKind::Method(_, eid) => is_relevant_expr(cx, cx.tcx.body_tables(eid), &cx.tcx.hir().body(eid).value), _ => false, } } -fn is_relevant_trait(tcx: TyCtxt<'_, '_, '_>, item: &TraitItem) -> bool { +fn is_relevant_trait(cx: &LateContext<'_, '_>, item: &TraitItem) -> bool { match item.node { TraitItemKind::Method(_, TraitMethod::Required(_)) => true, TraitItemKind::Method(_, TraitMethod::Provided(eid)) => { - is_relevant_expr(tcx, tcx.body_tables(eid), &tcx.hir.body(eid).value) + is_relevant_expr(cx, cx.tcx.body_tables(eid), &cx.tcx.hir().body(eid).value) }, _ => false, } } -fn is_relevant_block(tcx: TyCtxt<'_, '_, '_>, tables: &ty::TypeckTables<'_>, block: &Block) -> bool { +fn is_relevant_block(cx: &LateContext<'_, '_>, tables: &ty::TypeckTables<'_>, block: &Block) -> bool { if let Some(stmt) = block.stmts.first() { - match stmt.node { - StmtKind::Decl(_, _) => true, - StmtKind::Expr(ref expr, _) | StmtKind::Semi(ref expr, _) => is_relevant_expr(tcx, tables, expr), + match &stmt.node { + StmtKind::Local(_) => true, + StmtKind::Expr(expr) | StmtKind::Semi(expr) => is_relevant_expr(cx, tables, expr), + _ => false, } } else { - block.expr.as_ref().map_or(false, |e| is_relevant_expr(tcx, tables, e)) + block.expr.as_ref().map_or(false, |e| is_relevant_expr(cx, tables, e)) } } -fn is_relevant_expr(tcx: TyCtxt<'_, '_, '_>, tables: &ty::TypeckTables<'_>, expr: &Expr) -> bool { - match expr.node { - ExprKind::Block(ref block, _) => is_relevant_block(tcx, tables, block), - ExprKind::Ret(Some(ref e)) => is_relevant_expr(tcx, tables, e), +fn is_relevant_expr(cx: &LateContext<'_, '_>, tables: &ty::TypeckTables<'_>, expr: &Expr) -> bool { + match &expr.node { + ExprKind::Block(block, _) => is_relevant_block(cx, tables, block), + ExprKind::Ret(Some(e)) => is_relevant_expr(cx, tables, e), ExprKind::Ret(None) | ExprKind::Break(_, None) => false, - ExprKind::Call(ref path_expr, _) => if let ExprKind::Path(ref qpath) = path_expr.node { - if let Some(fun_id) = opt_def_id(tables.qpath_def(qpath, path_expr.hir_id)) { - !match_def_path(tcx, fun_id, &paths::BEGIN_PANIC) + ExprKind::Call(path_expr, _) => { + if let ExprKind::Path(qpath) = &path_expr.node { + if let Some(fun_id) = tables.qpath_def(qpath, path_expr.hir_id).opt_def_id() { + !cx.match_def_path(fun_id, &paths::BEGIN_PANIC) + } else { + true + } } else { true } - } else { - true }, _ => true, } @@ -435,14 +433,15 @@ fn check_attrs(cx: &LateContext<'_, '_>, span: Span, name: Name, attrs: &[Attrib cx, EMPTY_LINE_AFTER_OUTER_ATTR, begin_of_attr_to_item, - "Found an empty line after an outer attribute. Perhaps you forgot to add a '!' to make it an inner attribute?" + "Found an empty line after an outer attribute. \ + Perhaps you forgot to add a '!' to make it an inner attribute?", ); } } } - if let Some(ref values) = attr.meta_item_list() { - if values.len() != 1 || attr.name() != "inline" { + if let Some(values) = attr.meta_item_list() { + if values.len() != 1 || !attr.check_name("inline") { continue; } if is_word(&values[0], "always") { @@ -461,7 +460,7 @@ fn check_attrs(cx: &LateContext<'_, '_>, span: Span, name: Name, attrs: &[Attrib } fn check_semver(cx: &LateContext<'_, '_>, span: Span, lit: &Lit) { - if let LitKind::Str(ref is, _) = lit.node { + if let LitKind::Str(is, _) = lit.node { if Version::parse(&is.as_str()).is_ok() { return; } @@ -475,8 +474,8 @@ fn check_semver(cx: &LateContext<'_, '_>, span: Span, lit: &Lit) { } fn is_word(nmi: &NestedMetaItem, expected: &str) -> bool { - if let NestedMetaItemKind::MetaItem(ref mi) = nmi.node { - mi.is_word() && mi.name() == expected + if let NestedMetaItem::MetaItem(mi) = &nmi { + mi.is_word() && mi.check_name(expected) } else { false } @@ -496,42 +495,34 @@ fn is_present_in_source(cx: &LateContext<'_, '_>, span: Span) -> bool { true } -#[derive(Copy, Clone)] -pub struct CfgAttrPass; - -impl LintPass for CfgAttrPass { - fn get_lints(&self) -> LintArray { - lint_array!( - DEPRECATED_CFG_ATTR, - ) - } -} +declare_lint_pass!(DeprecatedCfgAttribute => [DEPRECATED_CFG_ATTR]); -impl EarlyLintPass for CfgAttrPass { +impl EarlyLintPass for DeprecatedCfgAttribute { fn check_attribute(&mut self, cx: &EarlyContext<'_>, attr: &Attribute) { if_chain! { // check cfg_attr - if attr.name() == "cfg_attr"; - if let Some(ref items) = attr.meta_item_list(); + if attr.check_name("cfg_attr"); + if let Some(items) = attr.meta_item_list(); if items.len() == 2; // check for `rustfmt` if let Some(feature_item) = items[0].meta_item(); - if feature_item.name() == "rustfmt"; + if feature_item.check_name("rustfmt"); // check for `rustfmt_skip` and `rustfmt::skip` if let Some(skip_item) = &items[1].meta_item(); - if skip_item.name() == "rustfmt_skip" || skip_item.name() == "skip"; + if skip_item.check_name("rustfmt_skip") || + skip_item.path.segments.last().expect("empty path in attribute").ident.name == "skip"; + // Only lint outer attributes, because custom inner attributes are unstable + // Tracking issue: https://github.com/rust-lang/rust/issues/54726 + if let AttrStyle::Outer = attr.style; then { - let attr_style = match attr.style { - AttrStyle::Outer => "#[", - AttrStyle::Inner => "#![", - }; span_lint_and_sugg( cx, DEPRECATED_CFG_ATTR, attr.span, "`cfg_attr` is deprecated for rustfmt and got replaced by tool_attributes", "use", - format!("{}rustfmt::skip]", attr_style), + "#[rustfmt::skip]".to_string(), + Applicability::MachineApplicable, ); } }