Auto merge of #3830 - flip1995:unknown_attribute, r=oli-obk

bors · bors · commit 275a3864b8d1 · 2019-02-28T19:20:06.000Z
Error on unknown or deprecated attributes

The reason I decided to not make this a lint is, that unknown attributes are always a hard error in rustc and also in rustfmt, which cannot be turned off by an `allow`. This could have been done by introducing a category which would be forbid-by-default. But that would have introduced a new lint category+group for just one lint and also wouldn't be consistent with rustfmt and rustc.
diff --git a/clippy_lints/src/utils/attrs.rs b/clippy_lints/src/utils/attrs.rs
@@ -0,0 +1,105 @@
+use rustc::session::Session;
+use rustc_errors::Applicability;
+use std::str::FromStr;
+use syntax::ast;
+
+/// Deprecation status of attributes known by Clippy.
+#[allow(dead_code)]
+pub enum DeprecationStatus {
+    /// Attribute is deprecated
+    Deprecated,
+    /// Attribute is deprecated and was replaced by the named attribute
+    Replaced(&'static str),
+    None,
+}
+
+pub const BUILTIN_ATTRIBUTES: &[(&str, DeprecationStatus)] = &[
+    ("author", DeprecationStatus::None),
+    ("cyclomatic_complexity", DeprecationStatus::None),
+    ("dump", DeprecationStatus::None),
+];
+
+pub struct LimitStack {
+    stack: Vec<u64>,
+}
+
+impl Drop for LimitStack {
+    fn drop(&mut self) {
+        assert_eq!(self.stack.len(), 1);
+    }
+}
+
+impl LimitStack {
+    pub fn new(limit: u64) -> Self {
+        Self { stack: vec![limit] }
+    }
+    pub fn limit(&self) -> u64 {
+        *self.stack.last().expect("there should always be a value in the stack")
+    }
+    pub fn push_attrs(&mut self, sess: &Session, attrs: &[ast::Attribute], name: &'static str) {
+        let stack = &mut self.stack;
+        parse_attrs(sess, attrs, name, |val| stack.push(val));
+    }
+    pub fn pop_attrs(&mut self, sess: &Session, attrs: &[ast::Attribute], name: &'static str) {
+        let stack = &mut self.stack;
+        parse_attrs(sess, attrs, name, |val| assert_eq!(stack.pop(), Some(val)));
+    }
+}
+
+pub fn get_attr<'a>(
+    sess: &'a Session,
+    attrs: &'a [ast::Attribute],
+    name: &'static str,
+) -> impl Iterator<Item = &'a ast::Attribute> {
+    attrs.iter().filter(move |attr| {
+        let attr_segments = &attr.path.segments;
+        if attr_segments.len() == 2 && attr_segments[0].ident.to_string() == "clippy" {
+            if let Some(deprecation_status) = BUILTIN_ATTRIBUTES
+                .iter()
+                .find(|(builtin_name, _)| *builtin_name == attr_segments[1].ident.to_string())
+                .map(|(_, deprecation_status)| deprecation_status)
+            {
+                let mut db = sess.struct_span_err(attr_segments[1].ident.span, "Usage of deprecated attribute");
+                match deprecation_status {
+                    DeprecationStatus::Deprecated => {
+                        db.emit();
+                        false
+                    },
+                    DeprecationStatus::Replaced(new_name) => {
+                        db.span_suggestion(
+                            attr_segments[1].ident.span,
+                            "consider using",
+                            new_name.to_string(),
+                            Applicability::MachineApplicable,
+                        );
+                        db.emit();
+                        false
+                    },
+                    DeprecationStatus::None => {
+                        db.cancel();
+                        attr_segments[1].ident.to_string() == name
+                    },
+                }
+            } else {
+                sess.span_err(attr_segments[1].ident.span, "Usage of unknown attribute");
+                false
+            }
+        } else {
+            false
+        }
+    })
+}
+
+fn parse_attrs<F: FnMut(u64)>(sess: &Session, attrs: &[ast::Attribute], name: &'static str, mut f: F) {
+    for attr in get_attr(sess, attrs, name) {
+        if let Some(ref value) = attr.value_str() {
+            if let Ok(value) = FromStr::from_str(&value.as_str()) {
+                f(value)
+            } else {
+                sess.span_err(attr.span, "not a number");
+            }
+        } else {
+            sess.span_err(attr.span, "bad clippy attribute");
+        }
+    }
+}
diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs
@@ -5,7 +5,8 @@ use crate::utils::get_attr;
 use rustc::hir;
 use rustc::hir::intravisit::{NestedVisitorMap, Visitor};
 use rustc::hir::{BindingAnnotation, Expr, ExprKind, Pat, PatKind, QPath, Stmt, StmtKind, TyKind};
-use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
+use rustc::lint::{LateContext, LateLintPass, LintArray, LintContext, LintPass};
+use rustc::session::Session;
 use rustc::{declare_tool_lint, lint_array};
 use rustc_data_structures::fx::FxHashMap;
 use syntax::ast::{Attribute, LitKind};
@@ -71,80 +72,80 @@ fn done() {
 }
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
-    fn check_item(&mut self, _cx: &LateContext<'a, 'tcx>, item: &'tcx hir::Item) {
-        if !has_attr(&item.attrs) {
+    fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::Item) {
+        if !has_attr(cx.sess(), &item.attrs) {
             return;
         }
         prelude();
         PrintVisitor::new("item").visit_item(item);
         done();
     }
 
-    fn check_impl_item(&mut self, _cx: &LateContext<'a, 'tcx>, item: &'tcx hir::ImplItem) {
-        if !has_attr(&item.attrs) {
+    fn check_impl_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::ImplItem) {
+        if !has_attr(cx.sess(), &item.attrs) {
             return;
         }
         prelude();
         PrintVisitor::new("item").visit_impl_item(item);
         done();
     }
 
-    fn check_trait_item(&mut self, _cx: &LateContext<'a, 'tcx>, item: &'tcx hir::TraitItem) {
-        if !has_attr(&item.attrs) {
+    fn check_trait_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::TraitItem) {
+        if !has_attr(cx.sess(), &item.attrs) {
             return;
         }
         prelude();
         PrintVisitor::new("item").visit_trait_item(item);
         done();
     }
 
-    fn check_variant(&mut self, _cx: &LateContext<'a, 'tcx>, var: &'tcx hir::Variant, generics: &hir::Generics) {
-        if !has_attr(&var.node.attrs) {
+    fn check_variant(&mut self, cx: &LateContext<'a, 'tcx>, var: &'tcx hir::Variant, generics: &hir::Generics) {
+        if !has_attr(cx.sess(), &var.node.attrs) {
             return;
         }
         prelude();
         PrintVisitor::new("var").visit_variant(var, generics, hir::DUMMY_HIR_ID);
         done();
     }
 
-    fn check_struct_field(&mut self, _cx: &LateContext<'a, 'tcx>, field: &'tcx hir::StructField) {
-        if !has_attr(&field.attrs) {
+    fn check_struct_field(&mut self, cx: &LateContext<'a, 'tcx>, field: &'tcx hir::StructField) {
+        if !has_attr(cx.sess(), &field.attrs) {
             return;
         }
         prelude();
         PrintVisitor::new("field").visit_struct_field(field);
         done();
     }
 
-    fn check_expr(&mut self, _cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) {
-        if !has_attr(&expr.attrs) {
+    fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) {
+        if !has_attr(cx.sess(), &expr.attrs) {
             return;
         }
         prelude();
         PrintVisitor::new("expr").visit_expr(expr);
         done();
     }
 
-    fn check_arm(&mut self, _cx: &LateContext<'a, 'tcx>, arm: &'tcx hir::Arm) {
-        if !has_attr(&arm.attrs) {
+    fn check_arm(&mut self, cx: &LateContext<'a, 'tcx>, arm: &'tcx hir::Arm) {
+        if !has_attr(cx.sess(), &arm.attrs) {
             return;
         }
         prelude();
         PrintVisitor::new("arm").visit_arm(arm);
         done();
     }
 
-    fn check_stmt(&mut self, _cx: &LateContext<'a, 'tcx>, stmt: &'tcx hir::Stmt) {
-        if !has_attr(stmt.node.attrs()) {
+    fn check_stmt(&mut self, cx: &LateContext<'a, 'tcx>, stmt: &'tcx hir::Stmt) {
+        if !has_attr(cx.sess(), stmt.node.attrs()) {
             return;
         }
         prelude();
         PrintVisitor::new("stmt").visit_stmt(stmt);
         done();
     }
 
-    fn check_foreign_item(&mut self, _cx: &LateContext<'a, 'tcx>, item: &'tcx hir::ForeignItem) {
-        if !has_attr(&item.attrs) {
+    fn check_foreign_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::ForeignItem) {
+        if !has_attr(cx.sess(), &item.attrs) {
             return;
         }
         prelude();
@@ -673,8 +674,8 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
     }
 }
 
-fn has_attr(attrs: &[Attribute]) -> bool {
-    get_attr(attrs, "author").count() > 0
+fn has_attr(sess: &Session, attrs: &[Attribute]) -> bool {
+    get_attr(sess, attrs, "author").count() > 0
 }
 
 fn desugaring_name(des: hir::MatchSource) -> String {
diff --git a/clippy_lints/src/utils/inspector.rs b/clippy_lints/src/utils/inspector.rs
@@ -3,7 +3,8 @@
 use crate::utils::get_attr;
 use rustc::hir;
 use rustc::hir::print;
-use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
+use rustc::lint::{LateContext, LateLintPass, LintArray, LintContext, LintPass};
+use rustc::session::Session;
 use rustc::{declare_tool_lint, lint_array};
 use syntax::ast::Attribute;
 
@@ -43,14 +44,14 @@ impl LintPass for Pass {
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
     fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::Item) {
-        if !has_attr(&item.attrs) {
+        if !has_attr(cx.sess(), &item.attrs) {
             return;
         }
         print_item(cx, item);
     }
 
     fn check_impl_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::ImplItem) {
-        if !has_attr(&item.attrs) {
+        if !has_attr(cx.sess(), &item.attrs) {
             return;
         }
         println!("impl item `{}`", item.ident.name);
@@ -100,14 +101,14 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
     //
 
     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) {
-        if !has_attr(&expr.attrs) {
+        if !has_attr(cx.sess(), &expr.attrs) {
             return;
         }
         print_expr(cx, expr, 0);
     }
 
     fn check_arm(&mut self, cx: &LateContext<'a, 'tcx>, arm: &'tcx hir::Arm) {
-        if !has_attr(&arm.attrs) {
+        if !has_attr(cx.sess(), &arm.attrs) {
             return;
         }
         for pat in &arm.pats {
@@ -122,7 +123,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
     }
 
     fn check_stmt(&mut self, cx: &LateContext<'a, 'tcx>, stmt: &'tcx hir::Stmt) {
-        if !has_attr(stmt.node.attrs()) {
+        if !has_attr(cx.sess(), stmt.node.attrs()) {
             return;
         }
         match stmt.node {
@@ -148,8 +149,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
     //
 }
 
-fn has_attr(attrs: &[Attribute]) -> bool {
-    get_attr(attrs, "dump").count() > 0
+fn has_attr(sess: &Session, attrs: &[Attribute]) -> bool {
+    get_attr(sess, attrs, "dump").count() > 0
 }
 
 #[allow(clippy::similar_names)]
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
@@ -8,7 +8,6 @@ use rustc::hir::intravisit::{NestedVisitorMap, Visitor};
 use rustc::hir::Node;
 use rustc::hir::*;
 use rustc::lint::{LateContext, Level, Lint, LintContext};
-use rustc::session::Session;
 use rustc::traits;
 use rustc::ty::{
     self,
@@ -20,32 +19,31 @@ use rustc_data_structures::sync::Lrc;
 use rustc_errors::Applicability;
 use std::borrow::Cow;
 use std::mem;
-use std::str::FromStr;
 use syntax::ast::{self, LitKind};
 use syntax::attr;
 use syntax::source_map::{Span, DUMMY_SP};
 use syntax::symbol;
 use syntax::symbol::{keywords, Symbol};
 
-pub mod camel_case;
-
+pub mod attrs;
 pub mod author;
+pub mod camel_case;
 pub mod comparisons;
 pub mod conf;
 pub mod constants;
 mod diagnostics;
+pub mod higher;
 mod hir_utils;
 pub mod inspector;
 pub mod internal_lints;
 pub mod paths;
 pub mod ptr;
 pub mod sugg;
 pub mod usage;
+pub use self::attrs::*;
 pub use self::diagnostics::*;
 pub use self::hir_utils::{SpanlessEq, SpanlessHash};
 
-pub mod higher;
-
 /// Returns true if the two spans come from differing expansions (i.e. one is
 /// from a macro and one
 /// isn't).
@@ -662,55 +660,6 @@ pub fn is_adjusted(cx: &LateContext<'_, '_>, e: &Expr) -> bool {
     cx.tables.adjustments().get(e.hir_id).is_some()
 }
 
-pub struct LimitStack {
-    stack: Vec<u64>,
-}
-
-impl Drop for LimitStack {
-    fn drop(&mut self) {
-        assert_eq!(self.stack.len(), 1);
-    }
-}
-
-impl LimitStack {
-    pub fn new(limit: u64) -> Self {
-        Self { stack: vec![limit] }
-    }
-    pub fn limit(&self) -> u64 {
-        *self.stack.last().expect("there should always be a value in the stack")
-    }
-    pub fn push_attrs(&mut self, sess: &Session, attrs: &[ast::Attribute], name: &'static str) {
-        let stack = &mut self.stack;
-        parse_attrs(sess, attrs, name, |val| stack.push(val));
-    }
-    pub fn pop_attrs(&mut self, sess: &Session, attrs: &[ast::Attribute], name: &'static str) {
-        let stack = &mut self.stack;
-        parse_attrs(sess, attrs, name, |val| assert_eq!(stack.pop(), Some(val)));
-    }
-}
-
-pub fn get_attr<'a>(attrs: &'a [ast::Attribute], name: &'static str) -> impl Iterator<Item = &'a ast::Attribute> {
-    attrs.iter().filter(move |attr| {
-        attr.path.segments.len() == 2
-            && attr.path.segments[0].ident.to_string() == "clippy"
-            && attr.path.segments[1].ident.to_string() == name
-    })
-}
-
-fn parse_attrs<F: FnMut(u64)>(sess: &Session, attrs: &[ast::Attribute], name: &'static str, mut f: F) {
-    for attr in get_attr(attrs, name) {
-        if let Some(ref value) = attr.value_str() {
-            if let Ok(value) = FromStr::from_str(&value.as_str()) {
-                f(value)
-            } else {
-                sess.span_err(attr.span, "not a number");
-            }
-        } else {
-            sess.span_err(attr.span, "bad clippy attribute");
-        }
-    }
-}
-
 /// Return the pre-expansion span if is this comes from an expansion of the
 /// macro `name`.
 /// See also `is_direct_expn_of`.
diff --git a/tests/ui/unknown_attribute.rs b/tests/ui/unknown_attribute.rs
@@ -0,0 +1,3 @@
+#[clippy::unknown]
+#[clippy::cyclomatic_complexity = "1"]
+fn main() {}
diff --git a/tests/ui/unknown_attribute.stderr b/tests/ui/unknown_attribute.stderr

Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,8 @@ use crate::utils::get_attr;`
`5`	`5`	`use rustc::hir;`
`6`	`6`	`use rustc::hir::intravisit::{NestedVisitorMap, Visitor};`
`7`	`7`	`use rustc::hir::{BindingAnnotation, Expr, ExprKind, Pat, PatKind, QPath, Stmt, StmtKind, TyKind};`
`8`		`-use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};`
	`8`	`+use rustc::lint::{LateContext, LateLintPass, LintArray, LintContext, LintPass};`
	`9`	`+use rustc::session::Session;`
`9`	`10`	`use rustc::{declare_tool_lint, lint_array};`
`10`	`11`	`use rustc_data_structures::fx::FxHashMap;`
`11`	`12`	`use syntax::ast::{Attribute, LitKind};`
`@@ -71,80 +72,80 @@ fn done() {`
`71`	`72`	`}`
`72`	`73`
`73`	`74`	`impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {`
`74`		`- fn check_item(&mut self, _cx: &LateContext<'a, 'tcx>, item: &'tcx hir::Item) {`
`75`		`- if !has_attr(&item.attrs) {`
	`75`	`+ fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::Item) {`
	`76`	`+ if !has_attr(cx.sess(), &item.attrs) {`
`76`	`77`	`return;`
`77`	`78`	`}`
`78`	`79`	`prelude();`
`79`	`80`	`PrintVisitor::new("item").visit_item(item);`
`80`	`81`	`done();`
`81`	`82`	`}`
`82`	`83`
`83`		`- fn check_impl_item(&mut self, _cx: &LateContext<'a, 'tcx>, item: &'tcx hir::ImplItem) {`
`84`		`- if !has_attr(&item.attrs) {`
	`84`	`+ fn check_impl_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::ImplItem) {`
	`85`	`+ if !has_attr(cx.sess(), &item.attrs) {`
`85`	`86`	`return;`
`86`	`87`	`}`
`87`	`88`	`prelude();`
`88`	`89`	`PrintVisitor::new("item").visit_impl_item(item);`
`89`	`90`	`done();`
`90`	`91`	`}`
`91`	`92`
`92`		`- fn check_trait_item(&mut self, _cx: &LateContext<'a, 'tcx>, item: &'tcx hir::TraitItem) {`
`93`		`- if !has_attr(&item.attrs) {`
	`93`	`+ fn check_trait_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::TraitItem) {`
	`94`	`+ if !has_attr(cx.sess(), &item.attrs) {`
`94`	`95`	`return;`
`95`	`96`	`}`
`96`	`97`	`prelude();`
`97`	`98`	`PrintVisitor::new("item").visit_trait_item(item);`
`98`	`99`	`done();`
`99`	`100`	`}`
`100`	`101`
`101`		`- fn check_variant(&mut self, _cx: &LateContext<'a, 'tcx>, var: &'tcx hir::Variant, generics: &hir::Generics) {`
`102`		`- if !has_attr(&var.node.attrs) {`
	`102`	`+ fn check_variant(&mut self, cx: &LateContext<'a, 'tcx>, var: &'tcx hir::Variant, generics: &hir::Generics) {`
	`103`	`+ if !has_attr(cx.sess(), &var.node.attrs) {`
`103`	`104`	`return;`
`104`	`105`	`}`
`105`	`106`	`prelude();`
`106`	`107`	`PrintVisitor::new("var").visit_variant(var, generics, hir::DUMMY_HIR_ID);`
`107`	`108`	`done();`
`108`	`109`	`}`
`109`	`110`
`110`		`- fn check_struct_field(&mut self, _cx: &LateContext<'a, 'tcx>, field: &'tcx hir::StructField) {`
`111`		`- if !has_attr(&field.attrs) {`
	`111`	`+ fn check_struct_field(&mut self, cx: &LateContext<'a, 'tcx>, field: &'tcx hir::StructField) {`
	`112`	`+ if !has_attr(cx.sess(), &field.attrs) {`
`112`	`113`	`return;`
`113`	`114`	`}`
`114`	`115`	`prelude();`
`115`	`116`	`PrintVisitor::new("field").visit_struct_field(field);`
`116`	`117`	`done();`
`117`	`118`	`}`
`118`	`119`
`119`		`- fn check_expr(&mut self, _cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) {`
`120`		`- if !has_attr(&expr.attrs) {`
	`120`	`+ fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) {`
	`121`	`+ if !has_attr(cx.sess(), &expr.attrs) {`
`121`	`122`	`return;`
`122`	`123`	`}`
`123`	`124`	`prelude();`
`124`	`125`	`PrintVisitor::new("expr").visit_expr(expr);`
`125`	`126`	`done();`
`126`	`127`	`}`
`127`	`128`
`128`		`- fn check_arm(&mut self, _cx: &LateContext<'a, 'tcx>, arm: &'tcx hir::Arm) {`
`129`		`- if !has_attr(&arm.attrs) {`
	`129`	`+ fn check_arm(&mut self, cx: &LateContext<'a, 'tcx>, arm: &'tcx hir::Arm) {`
	`130`	`+ if !has_attr(cx.sess(), &arm.attrs) {`
`130`	`131`	`return;`
`131`	`132`	`}`
`132`	`133`	`prelude();`
`133`	`134`	`PrintVisitor::new("arm").visit_arm(arm);`
`134`	`135`	`done();`
`135`	`136`	`}`
`136`	`137`
`137`		`- fn check_stmt(&mut self, _cx: &LateContext<'a, 'tcx>, stmt: &'tcx hir::Stmt) {`
`138`		`- if !has_attr(stmt.node.attrs()) {`
	`138`	`+ fn check_stmt(&mut self, cx: &LateContext<'a, 'tcx>, stmt: &'tcx hir::Stmt) {`
	`139`	`+ if !has_attr(cx.sess(), stmt.node.attrs()) {`
`139`	`140`	`return;`
`140`	`141`	`}`
`141`	`142`	`prelude();`
`142`	`143`	`PrintVisitor::new("stmt").visit_stmt(stmt);`
`143`	`144`	`done();`
`144`	`145`	`}`
`145`	`146`
`146`		`- fn check_foreign_item(&mut self, _cx: &LateContext<'a, 'tcx>, item: &'tcx hir::ForeignItem) {`
`147`		`- if !has_attr(&item.attrs) {`
	`147`	`+ fn check_foreign_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::ForeignItem) {`
	`148`	`+ if !has_attr(cx.sess(), &item.attrs) {`
`148`	`149`	`return;`
`149`	`150`	`}`
`150`	`151`	`prelude();`
`@@ -673,8 +674,8 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {`
`673`	`674`	`}`
`674`	`675`	`}`
`675`	`676`
`676`		`-fn has_attr(attrs: &[Attribute]) -> bool {`
`677`		`- get_attr(attrs, "author").count() > 0`
	`677`	`+fn has_attr(sess: &Session, attrs: &[Attribute]) -> bool {`
	`678`	`+ get_attr(sess, attrs, "author").count() > 0`
`678`	`679`	`}`
`679`	`680`
`680`	`681`	`fn desugaring_name(des: hir::MatchSource) -> String {`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,8 @@`
`3`	`3`	`use crate::utils::get_attr;`
`4`	`4`	`use rustc::hir;`
`5`	`5`	`use rustc::hir::print;`
`6`		`-use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};`
	`6`	`+use rustc::lint::{LateContext, LateLintPass, LintArray, LintContext, LintPass};`
	`7`	`+use rustc::session::Session;`
`7`	`8`	`use rustc::{declare_tool_lint, lint_array};`
`8`	`9`	`use syntax::ast::Attribute;`
`9`	`10`
`@@ -43,14 +44,14 @@ impl LintPass for Pass {`
`43`	`44`
`44`	`45`	`impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {`
`45`	`46`	`fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::Item) {`
`46`		`- if !has_attr(&item.attrs) {`
	`47`	`+ if !has_attr(cx.sess(), &item.attrs) {`
`47`	`48`	`return;`
`48`	`49`	`}`
`49`	`50`	`print_item(cx, item);`
`50`	`51`	`}`
`51`	`52`
`52`	`53`	`fn check_impl_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::ImplItem) {`
`53`		`- if !has_attr(&item.attrs) {`
	`54`	`+ if !has_attr(cx.sess(), &item.attrs) {`
`54`	`55`	`return;`
`55`	`56`	`}`
`56`	`57`	println!("impl item `{}`", item.ident.name);
`@@ -100,14 +101,14 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {`
`100`	`101`	`//`
`101`	`102`
`102`	`103`	`fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) {`
`103`		`- if !has_attr(&expr.attrs) {`
	`104`	`+ if !has_attr(cx.sess(), &expr.attrs) {`
`104`	`105`	`return;`
`105`	`106`	`}`
`106`	`107`	`print_expr(cx, expr, 0);`
`107`	`108`	`}`
`108`	`109`
`109`	`110`	`fn check_arm(&mut self, cx: &LateContext<'a, 'tcx>, arm: &'tcx hir::Arm) {`
`110`		`- if !has_attr(&arm.attrs) {`
	`111`	`+ if !has_attr(cx.sess(), &arm.attrs) {`
`111`	`112`	`return;`
`112`	`113`	`}`
`113`	`114`	`for pat in &arm.pats {`
`@@ -122,7 +123,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {`
`122`	`123`	`}`
`123`	`124`
`124`	`125`	`fn check_stmt(&mut self, cx: &LateContext<'a, 'tcx>, stmt: &'tcx hir::Stmt) {`
`125`		`- if !has_attr(stmt.node.attrs()) {`
	`126`	`+ if !has_attr(cx.sess(), stmt.node.attrs()) {`
`126`	`127`	`return;`
`127`	`128`	`}`
`128`	`129`	`match stmt.node {`
`@@ -148,8 +149,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {`
`148`	`149`	`//`
`149`	`150`	`}`
`150`	`151`
`151`		`-fn has_attr(attrs: &[Attribute]) -> bool {`
`152`		`- get_attr(attrs, "dump").count() > 0`
	`152`	`+fn has_attr(sess: &Session, attrs: &[Attribute]) -> bool {`
	`153`	`+ get_attr(sess, attrs, "dump").count() > 0`
`153`	`154`	`}`
`154`	`155`
`155`	`156`	`#[allow(clippy::similar_names)]`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+#[clippy::unknown]`
	`2`	`+#[clippy::cyclomatic_complexity = "1"]`
	`3`	`+fn main() {}`