[Jump to usage instructions](#usage)
##Lints
-There are 70 lints included in this crate:
+There are 71 lints included in this crate:
name | default | meaning
-------------------------------------------------------------------------------------------------------|---------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
[precedence](https://github.com/Manishearth/rust-clippy/wiki#precedence) | warn | catches operations where precedence may be unclear. See the wiki for a list of cases caught
[ptr_arg](https://github.com/Manishearth/rust-clippy/wiki#ptr_arg) | warn | fn arguments of the type `&Vec<...>` or `&String`, suggesting to use `&[...]` or `&str` instead, respectively
[range_step_by_zero](https://github.com/Manishearth/rust-clippy/wiki#range_step_by_zero) | warn | using Range::step_by(0), which produces an infinite iterator
+[range_zip_with_len](https://github.com/Manishearth/rust-clippy/wiki#range_zip_with_len) | warn | zipping iterator with a range when enumerate() would do
[redundant_closure](https://github.com/Manishearth/rust-clippy/wiki#redundant_closure) | warn | using redundant closures, i.e. `|a| foo(a)` (which can be written as just `foo`)
[redundant_pattern](https://github.com/Manishearth/rust-clippy/wiki#redundant_pattern) | warn | using `name @ _` in a pattern
[result_unwrap_used](https://github.com/Manishearth/rust-clippy/wiki#result_unwrap_used) | allow | using `Result.unwrap()`, which might be better handled
use rustc::lint::*;
use rustc_front::hir::*;
use syntax::codemap::Spanned;
-use utils::{match_type, is_integer_literal};
+use utils::{is_integer_literal, match_type, snippet};
declare_lint! {
pub RANGE_STEP_BY_ZERO, Warn,
"using Range::step_by(0), which produces an infinite iterator"
}
+declare_lint! {
+ pub RANGE_ZIP_WITH_LEN, Warn,
+ "zipping iterator with a range when enumerate() would do"
+}
#[derive(Copy,Clone)]
pub struct StepByZero;
impl LintPass for StepByZero {
fn get_lints(&self) -> LintArray {
- lint_array!(RANGE_STEP_BY_ZERO)
+ lint_array!(RANGE_STEP_BY_ZERO, RANGE_ZIP_WITH_LEN)
}
}
fn check_expr(&mut self, cx: &LateContext, expr: &Expr) {
if let ExprMethodCall(Spanned { node: ref name, .. }, _,
ref args) = expr.node {
- // Only warn on literal ranges.
+ // Range with step_by(0).
if name.as_str() == "step_by" && args.len() == 2 &&
is_range(cx, &args[0]) && is_integer_literal(&args[1], 0) {
cx.span_lint(RANGE_STEP_BY_ZERO, expr.span,
"Range::step_by(0) produces an infinite iterator. \
Consider using `std::iter::repeat()` instead")
}
+
+ // x.iter().zip(0..x.len())
+ else if name.as_str() == "zip" && args.len() == 2 {
+ let iter = &args[0].node;
+ let zip_arg = &args[1].node;
+ if_let_chain! {
+ [
+ // .iter() call
+ let &ExprMethodCall( Spanned { node: ref iter_name, .. }, _, ref iter_args ) = iter,
+ iter_name.as_str() == "iter",
+ // range expression in .zip() call: 0..x.len()
+ let &ExprRange(Some(ref from), Some(ref to)) = zip_arg,
+ is_integer_literal(from, 0),
+ // .len() call
+ let ExprMethodCall(Spanned { node: ref len_name, .. }, _, ref len_args) = to.node,
+ len_name.as_str() == "len" && len_args.len() == 1,
+ // .iter() and .len() called on same Path
+ let ExprPath(_, Path { segments: ref iter_path, .. }) = iter_args[0].node,
+ let ExprPath(_, Path { segments: ref len_path, .. }) = len_args[0].node,
+ iter_path == len_path
+ ], {
+ cx.span_lint(RANGE_ZIP_WITH_LEN, expr.span,
+ &format!("It is more idiomatic to use {}.iter().enumerate()",
+ snippet(cx, iter_args[0].span, "_")));
+ }
+ }
+ }
}
}
}