2015-08-16 06:54:43 +00:00
|
|
|
//! checks for attributes
|
2015-05-30 13:10:19 +00:00
|
|
|
|
2016-02-24 16:38:57 +00:00
|
|
|
use reexport::*;
|
2015-05-30 13:10:19 +00:00
|
|
|
use rustc::lint::*;
|
2016-04-07 15:46:48 +00:00
|
|
|
use rustc::hir::*;
|
2016-01-09 01:05:43 +00:00
|
|
|
use semver::Version;
|
2016-02-12 17:35:44 +00:00
|
|
|
use syntax::ast::{Attribute, Lit, LitKind, MetaItemKind};
|
2016-02-24 16:38:57 +00:00
|
|
|
use syntax::codemap::Span;
|
2016-08-17 09:36:04 +00:00
|
|
|
use utils::{in_macro, match_path, span_lint, span_lint_and_then, snippet_opt};
|
2016-04-14 16:13:15 +00:00
|
|
|
use utils::paths;
|
2015-05-30 13:10:19 +00:00
|
|
|
|
2016-08-06 07:55:04 +00:00
|
|
|
/// **What it does:** Checks for items annotated with `#[inline(always)]`,
|
|
|
|
/// unless the annotated function is empty or simply panics.
|
2015-12-11 00:22:27 +00:00
|
|
|
///
|
2016-08-06 07:55:04 +00:00
|
|
|
/// **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.
|
2015-12-11 00:22:27 +00:00
|
|
|
///
|
2016-08-06 07:55:04 +00:00
|
|
|
/// 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.
|
2015-12-11 00:22:27 +00:00
|
|
|
///
|
2016-08-06 07:55:04 +00:00
|
|
|
/// **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.
|
2015-12-11 00:22:27 +00:00
|
|
|
///
|
|
|
|
/// **Example:**
|
2016-07-15 22:25:44 +00:00
|
|
|
/// ```rust
|
2015-12-11 00:22:27 +00:00
|
|
|
/// #[inline(always)]
|
|
|
|
/// fn not_quite_hot_code(..) { ... }
|
|
|
|
/// ```
|
2016-02-05 23:13:29 +00:00
|
|
|
declare_lint! {
|
2016-08-06 08:18:36 +00:00
|
|
|
pub INLINE_ALWAYS,
|
|
|
|
Warn,
|
|
|
|
"use of `#[inline(always)]`"
|
2016-02-05 23:13:29 +00:00
|
|
|
}
|
2015-05-30 13:10:19 +00:00
|
|
|
|
2016-08-17 09:36:04 +00:00
|
|
|
/// **What it does:** Checks for `extern crate` and `use` items annotated with lint attributes
|
|
|
|
///
|
|
|
|
/// **Why is this bad?** Lint attributes have no effect on crate imports. Most 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.
|
|
|
|
///
|
|
|
|
/// **Example:**
|
|
|
|
/// ```rust
|
|
|
|
/// #[deny(dead_code)]
|
|
|
|
/// extern crate foo;
|
|
|
|
/// #[allow(unused_import)]
|
|
|
|
/// use foo::bar;
|
|
|
|
/// ```
|
|
|
|
declare_lint! {
|
|
|
|
pub USELESS_ATTRIBUTE,
|
|
|
|
Warn,
|
|
|
|
"use of lint attributes on `extern crate` items"
|
|
|
|
}
|
|
|
|
|
2016-08-06 07:55:04 +00:00
|
|
|
/// **What it does:** Checks for `#[deprecated]` annotations with a `since`
|
|
|
|
/// field that is not a valid semantic version.
|
2016-01-09 01:05:43 +00:00
|
|
|
///
|
2016-08-06 07:55:04 +00:00
|
|
|
/// **Why is this bad?** For checking the version of the deprecation, it must be
|
|
|
|
/// a valid semver. Failing that, the contained information is useless.
|
2016-01-09 01:05:43 +00:00
|
|
|
///
|
2016-08-06 07:55:04 +00:00
|
|
|
/// **Known problems:** None.
|
2016-01-09 01:05:43 +00:00
|
|
|
///
|
|
|
|
/// **Example:**
|
2016-07-15 22:25:44 +00:00
|
|
|
/// ```rust
|
2016-01-09 01:05:43 +00:00
|
|
|
/// #[deprecated(since = "forever")]
|
|
|
|
/// fn something_else(..) { ... }
|
|
|
|
/// ```
|
2016-02-05 23:13:29 +00:00
|
|
|
declare_lint! {
|
2016-08-06 08:18:36 +00:00
|
|
|
pub DEPRECATED_SEMVER,
|
|
|
|
Warn,
|
|
|
|
"use of `#[deprecated(since = \"x\")]` where x is not semver"
|
2016-02-05 23:13:29 +00:00
|
|
|
}
|
2015-05-30 13:10:19 +00:00
|
|
|
|
|
|
|
#[derive(Copy,Clone)]
|
|
|
|
pub struct AttrPass;
|
|
|
|
|
|
|
|
impl LintPass for AttrPass {
|
|
|
|
fn get_lints(&self) -> LintArray {
|
2016-08-17 09:36:04 +00:00
|
|
|
lint_array!(INLINE_ALWAYS, DEPRECATED_SEMVER, USELESS_ATTRIBUTE)
|
2015-05-30 13:10:19 +00:00
|
|
|
}
|
2015-09-19 02:53:04 +00:00
|
|
|
}
|
2015-08-11 18:22:20 +00:00
|
|
|
|
2015-09-19 02:53:04 +00:00
|
|
|
impl LateLintPass for AttrPass {
|
2016-01-09 01:05:43 +00:00
|
|
|
fn check_attribute(&mut self, cx: &LateContext, attr: &Attribute) {
|
2016-02-12 17:35:44 +00:00
|
|
|
if let MetaItemKind::List(ref name, ref items) = attr.node.value.node {
|
2016-01-09 01:05:43 +00:00
|
|
|
if items.is_empty() || name != &"deprecated" {
|
|
|
|
return;
|
|
|
|
}
|
2016-08-01 14:59:14 +00:00
|
|
|
for item in items {
|
2016-02-12 17:35:44 +00:00
|
|
|
if let MetaItemKind::NameValue(ref name, ref lit) = item.node {
|
2016-01-09 01:05:43 +00:00
|
|
|
if name == &"since" {
|
|
|
|
check_semver(cx, item.span, lit);
|
|
|
|
}
|
|
|
|
}
|
2016-01-30 12:48:39 +00:00
|
|
|
}
|
2016-01-09 01:05:43 +00:00
|
|
|
}
|
|
|
|
}
|
2016-01-30 12:48:39 +00:00
|
|
|
|
2015-09-19 02:53:04 +00:00
|
|
|
fn check_item(&mut self, cx: &LateContext, item: &Item) {
|
2015-08-11 18:22:20 +00:00
|
|
|
if is_relevant_item(item) {
|
2015-09-24 00:30:39 +00:00
|
|
|
check_attrs(cx, item.span, &item.name, &item.attrs)
|
2015-08-11 18:22:20 +00:00
|
|
|
}
|
2016-08-17 09:36:04 +00:00
|
|
|
match item.node {
|
|
|
|
ItemExternCrate(_) |
|
|
|
|
ItemUse(_) => {
|
|
|
|
for attr in &item.attrs {
|
|
|
|
if let MetaItemKind::List(ref name, _) = attr.node.value.node {
|
|
|
|
match &**name {
|
|
|
|
"allow" | "warn" | "deny" | "forbid" => {
|
|
|
|
span_lint_and_then(cx, USELESS_ATTRIBUTE, attr.span,
|
|
|
|
"useless lint attribute",
|
|
|
|
|db| {
|
|
|
|
if let Some(mut sugg) = snippet_opt(cx, attr.span) {
|
|
|
|
sugg.insert(1, '!');
|
|
|
|
db.span_suggestion(attr.span, "if you just forgot a `!`, use", sugg);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
},
|
|
|
|
_ => {},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
},
|
|
|
|
_ => {},
|
|
|
|
}
|
2015-08-11 18:22:20 +00:00
|
|
|
}
|
|
|
|
|
2015-09-19 02:53:04 +00:00
|
|
|
fn check_impl_item(&mut self, cx: &LateContext, item: &ImplItem) {
|
2015-08-11 18:22:20 +00:00
|
|
|
if is_relevant_impl(item) {
|
2015-09-24 00:30:39 +00:00
|
|
|
check_attrs(cx, item.span, &item.name, &item.attrs)
|
2015-08-11 18:22:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-09-19 02:53:04 +00:00
|
|
|
fn check_trait_item(&mut self, cx: &LateContext, item: &TraitItem) {
|
2015-08-11 18:22:20 +00:00
|
|
|
if is_relevant_trait(item) {
|
2015-09-24 00:30:39 +00:00
|
|
|
check_attrs(cx, item.span, &item.name, &item.attrs)
|
2015-08-11 18:22:20 +00:00
|
|
|
}
|
|
|
|
}
|
2015-06-07 10:03:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fn is_relevant_item(item: &Item) -> bool {
|
2015-11-24 17:44:40 +00:00
|
|
|
if let ItemFn(_, _, _, _, _, ref block) = item.node {
|
2015-08-11 18:22:20 +00:00
|
|
|
is_relevant_block(block)
|
2016-01-04 04:26:12 +00:00
|
|
|
} else {
|
|
|
|
false
|
|
|
|
}
|
2015-06-07 10:03:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fn is_relevant_impl(item: &ImplItem) -> bool {
|
2015-08-11 18:22:20 +00:00
|
|
|
match item.node {
|
2015-11-19 14:51:30 +00:00
|
|
|
ImplItemKind::Method(_, ref block) => is_relevant_block(block),
|
2016-01-04 04:26:12 +00:00
|
|
|
_ => false,
|
2015-08-11 18:22:20 +00:00
|
|
|
}
|
2015-06-07 10:03:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fn is_relevant_trait(item: &TraitItem) -> bool {
|
2015-08-11 18:22:20 +00:00
|
|
|
match item.node {
|
|
|
|
MethodTraitItem(_, None) => true,
|
|
|
|
MethodTraitItem(_, Some(ref block)) => is_relevant_block(block),
|
2016-01-04 04:26:12 +00:00
|
|
|
_ => false,
|
2015-08-11 18:22:20 +00:00
|
|
|
}
|
2015-06-07 10:03:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fn is_relevant_block(block: &Block) -> bool {
|
2015-08-13 13:36:31 +00:00
|
|
|
for stmt in &block.stmts {
|
2015-08-11 18:22:20 +00:00
|
|
|
match stmt.node {
|
|
|
|
StmtDecl(_, _) => return true,
|
2016-04-14 18:14:03 +00:00
|
|
|
StmtExpr(ref expr, _) |
|
|
|
|
StmtSemi(ref expr, _) => {
|
2015-08-11 18:22:20 +00:00
|
|
|
return is_relevant_expr(expr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-08-25 12:41:35 +00:00
|
|
|
block.expr.as_ref().map_or(false, |e| is_relevant_expr(e))
|
2015-06-07 10:03:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fn is_relevant_expr(expr: &Expr) -> bool {
|
2015-08-11 18:22:20 +00:00
|
|
|
match expr.node {
|
|
|
|
ExprBlock(ref block) => is_relevant_block(block),
|
2015-09-19 02:53:04 +00:00
|
|
|
ExprRet(Some(ref e)) => is_relevant_expr(e),
|
2015-09-03 14:42:17 +00:00
|
|
|
ExprRet(None) | ExprBreak(_) => false,
|
2015-08-11 18:22:20 +00:00
|
|
|
ExprCall(ref path_expr, _) => {
|
|
|
|
if let ExprPath(_, ref path) = path_expr.node {
|
2016-05-12 17:11:13 +00:00
|
|
|
!match_path(path, &paths::BEGIN_PANIC)
|
2016-01-04 04:26:12 +00:00
|
|
|
} else {
|
|
|
|
true
|
|
|
|
}
|
2015-08-11 18:22:20 +00:00
|
|
|
}
|
2016-01-04 04:26:12 +00:00
|
|
|
_ => true,
|
2015-08-11 18:22:20 +00:00
|
|
|
}
|
2015-05-30 13:10:19 +00:00
|
|
|
}
|
|
|
|
|
2016-01-04 04:26:12 +00:00
|
|
|
fn check_attrs(cx: &LateContext, span: Span, name: &Name, attrs: &[Attribute]) {
|
|
|
|
if in_macro(cx, span) {
|
|
|
|
return;
|
|
|
|
}
|
2015-08-11 18:22:20 +00:00
|
|
|
|
|
|
|
for attr in attrs {
|
2016-02-12 17:35:44 +00:00
|
|
|
if let MetaItemKind::List(ref inline, ref values) = attr.node.value.node {
|
2016-01-04 04:26:12 +00:00
|
|
|
if values.len() != 1 || inline != &"inline" {
|
|
|
|
continue;
|
|
|
|
}
|
2016-02-12 17:35:44 +00:00
|
|
|
if let MetaItemKind::Word(ref always) = values[0].node {
|
2016-01-04 04:26:12 +00:00
|
|
|
if always != &"always" {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
span_lint(cx,
|
|
|
|
INLINE_ALWAYS,
|
|
|
|
attr.span,
|
|
|
|
&format!("you have declared `#[inline(always)]` on `{}`. This is usually a bad idea",
|
|
|
|
name));
|
2015-08-11 18:22:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-05-30 13:10:19 +00:00
|
|
|
}
|
2016-01-09 01:05:43 +00:00
|
|
|
|
|
|
|
fn check_semver(cx: &LateContext, span: Span, lit: &Lit) {
|
2016-02-12 17:35:44 +00:00
|
|
|
if let LitKind::Str(ref is, _) = lit.node {
|
2016-01-09 01:05:43 +00:00
|
|
|
if Version::parse(&*is).is_ok() {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2016-01-30 12:48:39 +00:00
|
|
|
span_lint(cx,
|
2016-01-09 01:05:43 +00:00
|
|
|
DEPRECATED_SEMVER,
|
|
|
|
span,
|
|
|
|
"the since field must contain a semver-compliant version");
|
|
|
|
}
|