-use rustc::lint::*;
use rustc::hir::def_id::DefId;
-use rustc::ty;
use rustc::hir::*;
+use rustc::lint::*;
+use rustc::{declare_lint, lint_array};
+use rustc::ty;
+use std::collections::HashSet;
use syntax::ast::{Lit, LitKind, Name};
use syntax::codemap::{Span, Spanned};
-use utils::{get_item_name, in_macro, snippet, span_lint, span_lint_and_then, walk_ptrs_ty};
+use crate::utils::{get_item_name, in_macro, snippet, span_lint, span_lint_and_sugg, walk_ptrs_ty};
/// **What it does:** Checks for getting the length of something via `.len()`
/// just to compare to zero, and suggests using `.is_empty()` where applicable.
///
/// **Why is this bad?** Some structures can answer `.is_empty()` much faster
-/// than calculating their length. So it is good to get into the habit of using
-/// `.is_empty()`, and having it is cheap. Besides, it makes the intent clearer
-/// than a comparison.
+/// than calculating their length. Notably, for slices, getting the length
+/// requires a subtraction whereas `.is_empty()` is just a comparison. So it is
+/// good to get into the habit of using `.is_empty()`, and having it is cheap.
+/// Besides, it makes the intent clearer than a manual comparison.
///
/// **Known problems:** None.
///
/// ```rust
/// if x.len() == 0 { .. }
/// ```
-declare_lint! {
+declare_clippy_lint! {
pub LEN_ZERO,
- Warn,
+ style,
"checking `.len() == 0` or `.len() > 0` (or similar) when `.is_empty()` \
could be used instead"
}
/// pub fn len(&self) -> usize { .. }
/// }
/// ```
-declare_lint! {
+declare_clippy_lint! {
pub LEN_WITHOUT_IS_EMPTY,
- Warn,
+ style,
"traits or impls with a public `len` method but no corresponding `is_empty` method"
}
-#[derive(Copy,Clone)]
+#[derive(Copy, Clone)]
pub struct LenZero;
impl LintPass for LenZero {
}
match item.node {
- ItemTrait(_, _, _, ref trait_items) => check_trait_items(cx, item, trait_items),
- ItemImpl(_, _, _, _, None, _, ref impl_items) => check_impl_items(cx, item, impl_items),
+ ItemKind::Trait(_, _, _, _, ref trait_items) => check_trait_items(cx, item, trait_items),
+ ItemKind::Impl(_, _, _, _, None, _, ref impl_items) => check_impl_items(cx, item, impl_items),
_ => (),
}
}
return;
}
- if let ExprBinary(Spanned { node: cmp, .. }, ref left, ref right) = expr.node {
+ if let ExprKind::Binary(Spanned { node: cmp, .. }, ref left, ref right) = expr.node {
match cmp {
- BiEq => check_cmp(cx, expr.span, left, right, ""),
- BiGt | BiNe => check_cmp(cx, expr.span, left, right, "!"),
+ BinOpKind::Eq => {
+ check_cmp(cx, expr.span, left, right, "", 0); // len == 0
+ check_cmp(cx, expr.span, right, left, "", 0); // 0 == len
+ },
+ BinOpKind::Ne => {
+ check_cmp(cx, expr.span, left, right, "!", 0); // len != 0
+ check_cmp(cx, expr.span, right, left, "!", 0); // 0 != len
+ },
+ BinOpKind::Gt => {
+ check_cmp(cx, expr.span, left, right, "!", 0); // len > 0
+ check_cmp(cx, expr.span, right, left, "", 1); // 1 > len
+ },
+ BinOpKind::Lt => {
+ check_cmp(cx, expr.span, left, right, "", 1); // len < 1
+ check_cmp(cx, expr.span, right, left, "!", 0); // 0 < len
+ },
+ BinOpKind::Ge => check_cmp(cx, expr.span, left, right, "!", 1), // len <= 1
+ BinOpKind::Le => check_cmp(cx, expr.span, right, left, "!", 1), // 1 >= len
_ => (),
}
}
}
}
-fn check_trait_items(cx: &LateContext, item: &Item, trait_items: &[TraitItemRef]) {
+fn check_trait_items(cx: &LateContext, visited_trait: &Item, trait_items: &[TraitItemRef]) {
fn is_named_self(cx: &LateContext, item: &TraitItemRef, name: &str) -> bool {
- item.name == name &&
- if let AssociatedItemKind::Method { has_self } = item.kind {
- has_self &&
- {
+ item.ident.name == name && if let AssociatedItemKind::Method { has_self } = item.kind {
+ has_self && {
let did = cx.tcx.hir.local_def_id(item.id.node_id);
- let impl_ty = cx.tcx.type_of(did);
- impl_ty.fn_args().skip_binder().len() == 1
+ cx.tcx.fn_sig(did).inputs().skip_binder().len() == 1
}
} else {
false
}
}
- if !trait_items.iter().any(|i| is_named_self(cx, i, "is_empty")) {
- if let Some(i) = trait_items.iter().find(|i| is_named_self(cx, i, "len")) {
- if cx.access_levels.is_exported(i.id.node_id) {
- span_lint(cx,
- LEN_WITHOUT_IS_EMPTY,
- item.span,
- &format!("trait `{}` has a `len` method but no `is_empty` method", item.name));
+ // fill the set with current and super traits
+ fn fill_trait_set(traitt: DefId, set: &mut HashSet<DefId>, cx: &LateContext) {
+ if set.insert(traitt) {
+ for supertrait in ::rustc::traits::supertrait_def_ids(cx.tcx, traitt) {
+ fill_trait_set(supertrait, set, cx);
}
}
}
+
+ if cx.access_levels.is_exported(visited_trait.id) && trait_items.iter().any(|i| is_named_self(cx, i, "len")) {
+ let mut current_and_super_traits = HashSet::new();
+ let visited_trait_def_id = cx.tcx.hir.local_def_id(visited_trait.id);
+ fill_trait_set(visited_trait_def_id, &mut current_and_super_traits, cx);
+
+ let is_empty_method_found = current_and_super_traits
+ .iter()
+ .flat_map(|&i| cx.tcx.associated_items(i))
+ .any(|i| {
+ i.kind == ty::AssociatedKind::Method && i.method_has_self_argument && i.ident.name == "is_empty"
+ && cx.tcx.fn_sig(i.def_id).inputs().skip_binder().len() == 1
+ });
+
+ if !is_empty_method_found {
+ span_lint(
+ cx,
+ LEN_WITHOUT_IS_EMPTY,
+ visited_trait.span,
+ &format!(
+ "trait `{}` has a `len` method but no (possibly inherited) `is_empty` method",
+ visited_trait.name
+ ),
+ );
+ }
+ }
}
fn check_impl_items(cx: &LateContext, item: &Item, impl_items: &[ImplItemRef]) {
fn is_named_self(cx: &LateContext, item: &ImplItemRef, name: &str) -> bool {
- item.name == name &&
- if let AssociatedItemKind::Method { has_self } = item.kind {
- has_self &&
- {
+ item.ident.name == name && if let AssociatedItemKind::Method { has_self } = item.kind {
+ has_self && {
let did = cx.tcx.hir.local_def_id(item.id.node_id);
- let impl_ty = cx.tcx.type_of(did);
- impl_ty.fn_args().skip_binder().len() == 1
+ cx.tcx.fn_sig(did).inputs().skip_binder().len() == 1
}
} else {
false
let def_id = cx.tcx.hir.local_def_id(item.id);
let ty = cx.tcx.type_of(def_id);
- span_lint(cx,
- LEN_WITHOUT_IS_EMPTY,
- item.span,
- &format!("item `{}` has a public `len` method but {} `is_empty` method", ty, is_empty));
+ span_lint(
+ cx,
+ LEN_WITHOUT_IS_EMPTY,
+ item.span,
+ &format!(
+ "item `{}` has a public `len` method but {} `is_empty` method",
+ ty, is_empty
+ ),
+ );
}
}
}
-fn check_cmp(cx: &LateContext, span: Span, left: &Expr, right: &Expr, op: &str) {
- // check if we are in an is_empty() method
- if let Some(name) = get_item_name(cx, left) {
- if name == "is_empty" {
- return;
+fn check_cmp(cx: &LateContext, span: Span, method: &Expr, lit: &Expr, op: &str, compare_to: u32) {
+ if let (&ExprKind::MethodCall(ref method_path, _, ref args), &ExprKind::Lit(ref lit)) = (&method.node, &lit.node) {
+ // check if we are in an is_empty() method
+ if let Some(name) = get_item_name(cx, method) {
+ if name == "is_empty" {
+ return;
+ }
}
- }
- match (&left.node, &right.node) {
- (&ExprLit(ref lit), &ExprMethodCall(ref method, _, ref args)) |
- (&ExprMethodCall(ref method, _, ref args), &ExprLit(ref lit)) => {
- check_len_zero(cx, span, method.node, args, lit, op)
- },
- _ => (),
+
+ check_len(cx, span, method_path.ident.name, args, lit, op, compare_to)
}
}
-fn check_len_zero(cx: &LateContext, span: Span, name: Name, args: &[Expr], lit: &Lit, op: &str) {
- if let Spanned { node: LitKind::Int(0, _), .. } = *lit {
- if name == "len" && args.len() == 1 && has_is_empty(cx, &args[0]) {
- span_lint_and_then(cx, LEN_ZERO, span, "length comparison to zero", |db| {
- db.span_suggestion(span,
- "consider using `is_empty`",
- format!("{}{}.is_empty()", op, snippet(cx, args[0].span, "_")));
- });
+fn check_len(cx: &LateContext, span: Span, method_name: Name, args: &[Expr], lit: &Lit, op: &str, compare_to: u32) {
+ if let Spanned {
+ node: LitKind::Int(lit, _),
+ ..
+ } = *lit
+ {
+ // check if length is compared to the specified number
+ if lit != u128::from(compare_to) {
+ return;
+ }
+
+ if method_name == "len" && args.len() == 1 && has_is_empty(cx, &args[0]) {
+ span_lint_and_sugg(
+ cx,
+ LEN_ZERO,
+ span,
+ &format!("length comparison to {}", if compare_to == 0 { "zero" } else { "one" }),
+ "using `is_empty` is more concise",
+ format!("{}{}.is_empty()", op, snippet(cx, args[0].span, "_")),
+ );
}
}
}
/// Get an `AssociatedItem` and return true if it matches `is_empty(self)`.
fn is_is_empty(cx: &LateContext, item: &ty::AssociatedItem) -> bool {
if let ty::AssociatedKind::Method = item.kind {
- if item.name == "is_empty" {
- let sig = cx.tcx.type_of(item.def_id).fn_sig();
+ if item.ident.name == "is_empty" {
+ let sig = cx.tcx.fn_sig(item.def_id);
let ty = sig.skip_binder();
ty.inputs().len() == 1
} else {
/// Check the inherent impl's items for an `is_empty(self)` method.
fn has_is_empty_impl(cx: &LateContext, id: DefId) -> bool {
- cx.tcx.inherent_impls(id)
- .iter()
- .any(|imp| cx.tcx.associated_items(*imp).any(|item| is_is_empty(cx, &item)))
+ cx.tcx.inherent_impls(id).iter().any(|imp| {
+ cx.tcx
+ .associated_items(*imp)
+ .any(|item| is_is_empty(cx, &item))
+ })
}
let ty = &walk_ptrs_ty(cx.tables.expr_ty(expr));
match ty.sty {
- ty::TyDynamic(..) => {
- cx.tcx
- .associated_items(ty.ty_to_def_id().expect("trait impl not found"))
- .any(|item| is_is_empty(cx, &item))
- },
- ty::TyProjection(_) => ty.ty_to_def_id().map_or(false, |id| has_is_empty_impl(cx, id)),
+ ty::TyDynamic(ref tt, ..) => cx.tcx
+ .associated_items(tt.principal().expect("trait impl not found").def_id())
+ .any(|item| is_is_empty(cx, &item)),
+ ty::TyProjection(ref proj) => has_is_empty_impl(cx, proj.item_def_id),
ty::TyAdt(id, _) => has_is_empty_impl(cx, id.did),
ty::TyArray(..) | ty::TySlice(..) | ty::TyStr => true,
_ => false,
projects / rust.git / blobdiff