2015-08-16 06:54:43 +00:00
|
|
|
|
use rustc::lint::*;
|
2016-04-07 15:46:48 +00:00
|
|
|
|
use rustc::hir::def_id::DefId;
|
2016-11-16 20:57:56 +00:00
|
|
|
|
use rustc::ty;
|
2016-04-07 15:46:48 +00:00
|
|
|
|
use rustc::hir::*;
|
2017-08-28 21:13:56 +00:00
|
|
|
|
use std::collections::HashSet;
|
2016-02-24 16:38:57 +00:00
|
|
|
|
use syntax::ast::{Lit, LitKind, Name};
|
|
|
|
|
use syntax::codemap::{Span, Spanned};
|
2017-06-21 18:04:04 +00:00
|
|
|
|
use utils::{get_item_name, in_macro, snippet, span_lint, span_lint_and_sugg, walk_ptrs_ty};
|
2015-05-20 06:52:19 +00:00
|
|
|
|
|
2016-08-06 07:55:04 +00:00
|
|
|
|
/// **What it does:** Checks for getting the length of something via `.len()`
|
|
|
|
|
/// just to compare to zero, and suggests using `.is_empty()` where applicable.
|
2015-12-11 00:22:27 +00:00
|
|
|
|
///
|
2016-08-06 07:55:04 +00:00
|
|
|
|
/// **Why is this bad?** Some structures can answer `.is_empty()` much faster
|
2017-08-12 22:14:28 +00:00
|
|
|
|
/// 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.
|
2015-12-11 00:22:27 +00:00
|
|
|
|
///
|
2016-08-06 07:55:04 +00:00
|
|
|
|
/// **Known problems:** None.
|
2015-12-11 00:22:27 +00:00
|
|
|
|
///
|
2016-07-15 22:25:44 +00:00
|
|
|
|
/// **Example:**
|
|
|
|
|
/// ```rust
|
|
|
|
|
/// if x.len() == 0 { .. }
|
|
|
|
|
/// ```
|
2016-02-05 23:13:29 +00:00
|
|
|
|
declare_lint! {
|
2016-08-06 08:18:36 +00:00
|
|
|
|
pub LEN_ZERO,
|
|
|
|
|
Warn,
|
2016-02-05 23:13:29 +00:00
|
|
|
|
"checking `.len() == 0` or `.len() > 0` (or similar) when `.is_empty()` \
|
|
|
|
|
could be used instead"
|
|
|
|
|
}
|
2015-05-20 06:52:19 +00:00
|
|
|
|
|
2016-08-06 07:55:04 +00:00
|
|
|
|
/// **What it does:** Checks for items that implement `.len()` but not
|
|
|
|
|
/// `.is_empty()`.
|
2015-12-11 00:22:27 +00:00
|
|
|
|
///
|
2016-08-06 07:55:04 +00:00
|
|
|
|
/// **Why is this bad?** It is good custom to have both methods, because for
|
|
|
|
|
/// some data structures, asking about the length will be a costly operation,
|
|
|
|
|
/// whereas `.is_empty()` can usually answer in constant time. Also it used to
|
|
|
|
|
/// lead to false positives on the [`len_zero`](#len_zero) lint – currently that
|
|
|
|
|
/// lint will ignore such entities.
|
2015-12-11 00:22:27 +00:00
|
|
|
|
///
|
2016-08-06 07:55:04 +00:00
|
|
|
|
/// **Known problems:** None.
|
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
|
|
|
|
/// impl X {
|
2016-08-29 21:06:59 +00:00
|
|
|
|
/// pub fn len(&self) -> usize { .. }
|
2015-12-11 00:22:27 +00:00
|
|
|
|
/// }
|
|
|
|
|
/// ```
|
2016-02-05 23:13:29 +00:00
|
|
|
|
declare_lint! {
|
2016-08-06 08:18:36 +00:00
|
|
|
|
pub LEN_WITHOUT_IS_EMPTY,
|
|
|
|
|
Warn,
|
2016-08-29 21:06:59 +00:00
|
|
|
|
"traits or impls with a public `len` method but no corresponding `is_empty` method"
|
2016-02-05 23:13:29 +00:00
|
|
|
|
}
|
2015-05-20 06:52:19 +00:00
|
|
|
|
|
2017-08-09 07:30:56 +00:00
|
|
|
|
#[derive(Copy, Clone)]
|
2015-05-20 06:52:19 +00:00
|
|
|
|
pub struct LenZero;
|
|
|
|
|
|
|
|
|
|
impl LintPass for LenZero {
|
2015-08-11 18:22:20 +00:00
|
|
|
|
fn get_lints(&self) -> LintArray {
|
2015-05-20 06:52:19 +00:00
|
|
|
|
lint_array!(LEN_ZERO, LEN_WITHOUT_IS_EMPTY)
|
2015-08-11 18:22:20 +00:00
|
|
|
|
}
|
2015-09-19 02:53:04 +00:00
|
|
|
|
}
|
2015-08-11 18:22:20 +00:00
|
|
|
|
|
2016-12-07 12:13:40 +00:00
|
|
|
|
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LenZero {
|
|
|
|
|
fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) {
|
2017-03-31 22:14:04 +00:00
|
|
|
|
if in_macro(item.span) {
|
2016-02-24 19:53:15 +00:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-21 18:44:48 +00:00
|
|
|
|
match item.node {
|
2016-01-04 04:26:12 +00:00
|
|
|
|
ItemTrait(_, _, _, ref trait_items) => check_trait_items(cx, item, trait_items),
|
2017-04-28 11:00:42 +00:00
|
|
|
|
ItemImpl(_, _, _, _, None, _, ref impl_items) => check_impl_items(cx, item, impl_items),
|
2016-01-04 04:26:12 +00:00
|
|
|
|
_ => (),
|
2015-08-11 18:22:20 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-12-07 12:13:40 +00:00
|
|
|
|
fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
|
2017-03-31 22:14:04 +00:00
|
|
|
|
if in_macro(expr.span) {
|
2016-02-24 19:53:15 +00:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2016-04-14 18:14:03 +00:00
|
|
|
|
if let ExprBinary(Spanned { node: cmp, .. }, ref left, ref right) = expr.node {
|
2015-09-06 18:57:06 +00:00
|
|
|
|
match cmp {
|
|
|
|
|
BiEq => check_cmp(cx, expr.span, left, right, ""),
|
|
|
|
|
BiGt | BiNe => check_cmp(cx, expr.span, left, right, "!"),
|
2016-01-04 04:26:12 +00:00
|
|
|
|
_ => (),
|
2015-08-11 18:22:20 +00:00
|
|
|
|
}
|
2015-09-06 18:57:06 +00:00
|
|
|
|
}
|
2015-08-11 18:22:20 +00:00
|
|
|
|
}
|
2015-05-20 06:52:19 +00:00
|
|
|
|
}
|
|
|
|
|
|
2017-08-28 21:13:56 +00:00
|
|
|
|
fn check_trait_items(cx: &LateContext, visited_trait: &Item, trait_items: &[TraitItemRef]) {
|
2017-01-04 21:06:38 +00:00
|
|
|
|
fn is_named_self(cx: &LateContext, item: &TraitItemRef, name: &str) -> bool {
|
2017-03-30 08:21:13 +00:00
|
|
|
|
item.name == name &&
|
2017-08-09 07:30:56 +00:00
|
|
|
|
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
|
2017-01-04 21:06:38 +00:00
|
|
|
|
}
|
2015-08-11 18:22:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
2017-08-28 21:13:56 +00:00
|
|
|
|
// 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) {
|
|
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
}
|
2015-08-11 18:22:20 +00:00
|
|
|
|
}
|
2016-01-04 04:26:12 +00:00
|
|
|
|
}
|
2015-08-11 18:22:20 +00:00
|
|
|
|
}
|
2017-08-28 21:13:56 +00:00
|
|
|
|
|
|
|
|
|
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 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"));
|
|
|
|
|
|
|
|
|
|
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
|
|
|
|
|
),
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
}
|
2015-05-20 06:52:19 +00:00
|
|
|
|
}
|
|
|
|
|
|
2016-11-19 23:13:08 +00:00
|
|
|
|
fn check_impl_items(cx: &LateContext, item: &Item, impl_items: &[ImplItemRef]) {
|
|
|
|
|
fn is_named_self(cx: &LateContext, item: &ImplItemRef, name: &str) -> bool {
|
2017-03-30 08:21:13 +00:00
|
|
|
|
item.name == name &&
|
2017-08-09 07:30:56 +00:00
|
|
|
|
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
|
2016-11-19 23:13:08 +00:00
|
|
|
|
}
|
2015-08-11 18:22:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
2016-11-19 23:13:08 +00:00
|
|
|
|
let is_empty = if let Some(is_empty) = impl_items.iter().find(|i| is_named_self(cx, i, "is_empty")) {
|
|
|
|
|
if cx.access_levels.is_exported(is_empty.id.node_id) {
|
2016-08-29 21:06:59 +00:00
|
|
|
|
return;
|
|
|
|
|
} else {
|
|
|
|
|
"a private"
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
"no corresponding"
|
|
|
|
|
};
|
|
|
|
|
|
2016-11-19 23:13:08 +00:00
|
|
|
|
if let Some(i) = impl_items.iter().find(|i| is_named_self(cx, i, "len")) {
|
|
|
|
|
if cx.access_levels.is_exported(i.id.node_id) {
|
2017-02-02 16:53:28 +00:00
|
|
|
|
let def_id = cx.tcx.hir.local_def_id(item.id);
|
2017-04-27 12:00:35 +00:00
|
|
|
|
let ty = cx.tcx.type_of(def_id);
|
2016-08-29 21:06:59 +00:00
|
|
|
|
|
2017-08-09 07:30:56 +00:00
|
|
|
|
span_lint(
|
|
|
|
|
cx,
|
|
|
|
|
LEN_WITHOUT_IS_EMPTY,
|
|
|
|
|
item.span,
|
|
|
|
|
&format!("item `{}` has a public `len` method but {} `is_empty` method", ty, is_empty),
|
|
|
|
|
);
|
2015-08-11 18:22:20 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2015-05-20 06:52:19 +00:00
|
|
|
|
}
|
|
|
|
|
|
2015-09-28 05:11:03 +00:00
|
|
|
|
fn check_cmp(cx: &LateContext, span: Span, left: &Expr, right: &Expr, op: &str) {
|
|
|
|
|
// check if we are in an is_empty() method
|
2015-09-06 19:03:09 +00:00
|
|
|
|
if let Some(name) = get_item_name(cx, left) {
|
2017-03-30 08:21:13 +00:00
|
|
|
|
if name == "is_empty" {
|
2016-01-04 04:26:12 +00:00
|
|
|
|
return;
|
|
|
|
|
}
|
2015-09-06 18:57:06 +00:00
|
|
|
|
}
|
2015-08-11 18:22:20 +00:00
|
|
|
|
match (&left.node, &right.node) {
|
2017-07-10 08:17:40 +00:00
|
|
|
|
(&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)
|
2016-12-20 17:21:30 +00:00
|
|
|
|
},
|
2016-01-04 04:26:12 +00:00
|
|
|
|
_ => (),
|
2015-08-11 18:22:20 +00:00
|
|
|
|
}
|
2015-05-20 06:52:19 +00:00
|
|
|
|
}
|
|
|
|
|
|
2017-03-30 08:21:13 +00:00
|
|
|
|
fn check_len_zero(cx: &LateContext, span: Span, name: Name, args: &[Expr], lit: &Lit, op: &str) {
|
2016-04-14 18:14:03 +00:00
|
|
|
|
if let Spanned { node: LitKind::Int(0, _), .. } = *lit {
|
2017-03-30 08:21:13 +00:00
|
|
|
|
if name == "len" && args.len() == 1 && has_is_empty(cx, &args[0]) {
|
2017-08-09 07:30:56 +00:00
|
|
|
|
span_lint_and_sugg(
|
|
|
|
|
cx,
|
|
|
|
|
LEN_ZERO,
|
|
|
|
|
span,
|
|
|
|
|
"length comparison to zero",
|
|
|
|
|
"using `is_empty` is more concise",
|
|
|
|
|
format!("{}{}.is_empty()", op, snippet(cx, args[0].span, "_")),
|
|
|
|
|
);
|
2016-01-04 04:26:12 +00:00
|
|
|
|
}
|
2015-08-11 18:22:20 +00:00
|
|
|
|
}
|
2015-05-20 06:52:19 +00:00
|
|
|
|
}
|
2015-06-01 05:40:33 +00:00
|
|
|
|
|
2016-03-19 16:48:29 +00:00
|
|
|
|
/// Check if this type has an `is_empty` method.
|
2015-09-19 02:53:04 +00:00
|
|
|
|
fn has_is_empty(cx: &LateContext, expr: &Expr) -> bool {
|
2016-11-16 20:57:56 +00:00
|
|
|
|
/// 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 {
|
2017-03-30 08:21:13 +00:00
|
|
|
|
if item.name == "is_empty" {
|
2017-06-29 13:38:25 +00:00
|
|
|
|
let sig = cx.tcx.fn_sig(item.def_id);
|
2017-03-01 12:24:19 +00:00
|
|
|
|
let ty = sig.skip_binder();
|
2016-12-11 07:57:19 +00:00
|
|
|
|
ty.inputs().len() == 1
|
2016-11-16 20:57:56 +00:00
|
|
|
|
} else {
|
|
|
|
|
false
|
|
|
|
|
}
|
2016-01-04 04:26:12 +00:00
|
|
|
|
} else {
|
|
|
|
|
false
|
|
|
|
|
}
|
2015-08-11 18:22:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
2016-03-19 16:48:29 +00:00
|
|
|
|
/// Check the inherent impl's items for an `is_empty(self)` method.
|
2016-09-22 00:51:12 +00:00
|
|
|
|
fn has_is_empty_impl(cx: &LateContext, id: DefId) -> bool {
|
2017-08-09 07:30:56 +00:00
|
|
|
|
cx.tcx.inherent_impls(id).iter().any(|imp| {
|
|
|
|
|
cx.tcx.associated_items(*imp).any(
|
|
|
|
|
|item| is_is_empty(cx, &item),
|
|
|
|
|
)
|
|
|
|
|
})
|
2015-08-11 18:22:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
2017-01-13 16:04:56 +00:00
|
|
|
|
let ty = &walk_ptrs_ty(cx.tables.expr_ty(expr));
|
2015-08-11 18:22:20 +00:00
|
|
|
|
match ty.sty {
|
2016-12-06 10:32:21 +00:00
|
|
|
|
ty::TyDynamic(..) => {
|
2016-01-04 04:26:12 +00:00
|
|
|
|
cx.tcx
|
2016-12-20 17:21:30 +00:00
|
|
|
|
.associated_items(ty.ty_to_def_id().expect("trait impl not found"))
|
|
|
|
|
.any(|item| is_is_empty(cx, &item))
|
|
|
|
|
},
|
2017-08-09 07:30:56 +00:00
|
|
|
|
ty::TyProjection(_) => {
|
|
|
|
|
ty.ty_to_def_id().map_or(
|
|
|
|
|
false,
|
|
|
|
|
|id| has_is_empty_impl(cx, id),
|
|
|
|
|
)
|
|
|
|
|
},
|
2016-09-22 00:51:12 +00:00
|
|
|
|
ty::TyAdt(id, _) => has_is_empty_impl(cx, id.did),
|
2017-02-25 03:26:33 +00:00
|
|
|
|
ty::TyArray(..) | ty::TySlice(..) | ty::TyStr => true,
|
2015-08-11 18:22:20 +00:00
|
|
|
|
_ => false,
|
|
|
|
|
}
|
2015-06-01 05:40:33 +00:00
|
|
|
|
}
|