-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_sugg, 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.
/// ```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"
}
}
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, 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 &&
- {
- let did = cx.tcx.hir.local_def_id(item.id.node_id);
- cx.tcx.fn_sig(did).inputs().skip_binder().len() == 1
- }
- } else {
- false
+ 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);
+ cx.tcx.fn_sig(did).inputs().skip_binder().len() == 1
}
+ } else {
+ false
+ }
}
// fill the set with current and super traits
- fn fill_trait_set<'a, 'b: 'a>(traitt: &'b Item, set: &'a mut HashSet<&'b Item>, cx: &'b LateContext) {
+ fn fill_trait_set(traitt: DefId, set: &mut HashSet<DefId>, cx: &LateContext) {
if set.insert(traitt) {
- if let ItemTrait(.., ref ty_param_bounds, _) = traitt.node {
- for ty_param_bound in ty_param_bounds {
- if let TraitTyParamBound(ref poly_trait_ref, _) = *ty_param_bound {
- let super_trait_node_id = cx.tcx
- .hir
- .as_local_node_id(poly_trait_ref.trait_ref.path.def.def_id())
- .expect("the DefId is local, the NodeId should be available");
- let super_trait = cx.tcx.hir.expect_item(super_trait_node_id);
- fill_trait_set(super_trait, set, cx);
- }
- }
+ 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"))
- {
+ 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();
- fill_trait_set(visited_trait, &mut current_and_super_traits, cx);
+ 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| match i.node {
- ItemTrait(.., ref trait_items) => trait_items.iter(),
- _ => bug!("should only handle traits"),
- })
- .any(|i| is_named_self(cx, i, "is_empty"));
+ .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(
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 &&
- {
- let did = cx.tcx.hir.local_def_id(item.id.node_id);
- cx.tcx.fn_sig(did).inputs().skip_binder().len() == 1
- }
- } else {
- false
+ 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);
+ cx.tcx.fn_sig(did).inputs().skip_binder().len() == 1
}
+ } else {
+ false
+ }
}
let is_empty = if let Some(is_empty) = impl_items.iter().find(|i| is_named_self(cx, i, "is_empty")) {
cx,
LEN_WITHOUT_IS_EMPTY,
item.span,
- &format!("item `{}` has a public `len` method but {} `is_empty` method", ty, is_empty),
+ &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_path, _, ref args)) |
- (&ExprMethodCall(ref method_path, _, ref args), &ExprLit(ref lit)) => {
- check_len_zero(cx, span, method_path.name, 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]) {
+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,
- "length comparison to zero",
+ &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" {
+ if item.ident.name == "is_empty" {
let sig = cx.tcx.fn_sig(item.def_id);
let ty = sig.skip_binder();
ty.inputs().len() == 1
/// 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
+ .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