]> git.lizzy.rs Git - rust.git/blobdiff - clippy_lints/src/attrs.rs
Merge branch 'macro-use' into HEAD
[rust.git] / clippy_lints / src / attrs.rs
index 0523e4d468075d1a8aa28a73ed73d035a1a3ae89..6d4d333a8cb9638bb3f1bdb9339b6c30e15bbce1 100644 (file)
@@ -7,6 +7,8 @@
 };
 use rustc::hir::*;
 use rustc::lint::*;
+use rustc::{declare_lint, lint_array};
+use if_chain::if_chain;
 use rustc::ty::{self, TyCtxt};
 use semver::Version;
 use syntax::ast::{AttrStyle, Attribute, Lit, LitKind, MetaItemKind, NestedMetaItem, NestedMetaItemKind};
 }
 
 /// **What it does:** Checks for `extern crate` and `use` items annotated with
-/// lint attributes
+/// 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
+/// likely a `!` was forgotten.
 ///
-/// **Known problems:** Technically one might allow `unused_import` on a `use`
-/// item,
-/// but it's easier to remove the unused item.
+/// **Known problems:** None.
 ///
 /// **Example:**
 /// ```rust
+/// // Bad
 /// #[deny(dead_code)]
 /// extern crate foo;
-/// #[allow(unused_import)]
+/// #[forbid(dead_code)]
 /// use foo::bar;
+///
+/// // Ok
+/// #[allow(unused_imports)]
+/// use foo::baz;
+/// #[allow(unused_imports)]
+/// #[macro_use]
+/// extern crate baz;
 /// ```
 declare_clippy_lint! {
     pub USELESS_ATTRIBUTE,
@@ -154,17 +165,26 @@ fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) {
             check_attrs(cx, item.span, item.name, &item.attrs)
         }
         match item.node {
-            ItemExternCrate(_) | ItemUse(_, _) => {
+            ItemKind::ExternCrate(..) | ItemKind::Use(..) => {
+                let skip_unused_imports = item.attrs.iter().any(|attr| attr.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`
+                                // whitelist `unused_imports` and `deprecated` for `use` items
+                                // and `unused_imports` for `extern crate` items with `macro_use`
                                 for lint in lint_list {
-                                    if is_word(lint, "unused_imports") || is_word(lint, "deprecated") {
-                                        if let ItemUse(_, _) = item.node {
-                                            return;
-                                        }
+                                    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
+                                        },
+                                        _ => {},
                                     }
                                 }
                                 let line_span = last_line_of_span(cx, attr.span);
@@ -207,7 +227,7 @@ fn check_trait_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx TraitItem
 }
 
 fn is_relevant_item(tcx: TyCtxt, item: &Item) -> bool {
-    if let ItemFn(_, _, _, eid) = item.node {
+    if let ItemKind::Fn(_, _, _, eid) = item.node {
         is_relevant_expr(tcx, tcx.body_tables(eid), &tcx.hir.body(eid).value)
     } else {
         true