rust-clippy/clippy_lints/src/infinite_iter.rs

263 lines
8.4 KiB
Rust
Raw Normal View History

2018-10-06 16:18:06 +00:00
// Copyright 2014-2018 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use crate::utils::{get_trait_def_id, higher, implements_trait, match_qpath, match_type, paths, span_lint};
use rustc::hir::*;
use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
use rustc::{declare_tool_lint, lint_array};
/// **What it does:** Checks for iteration that is guaranteed to be infinite.
///
/// **Why is this bad?** While there may be places where this is acceptable
/// (e.g. in event streams), in most cases this is simply an error.
///
/// **Known problems:** None.
///
/// **Example:**
/// ```rust
/// repeat(1_u8).iter().collect::<Vec<_>>()
/// ```
2018-03-28 13:24:26 +00:00
declare_clippy_lint! {
pub INFINITE_ITER,
2018-03-28 13:24:26 +00:00
correctness,
"infinite iteration"
}
/// **What it does:** Checks for iteration that may be infinite.
///
/// **Why is this bad?** While there may be places where this is acceptable
/// (e.g. in event streams), in most cases this is simply an error.
///
/// **Known problems:** The code may have a condition to stop iteration, but
/// this lint is not clever enough to analyze it.
///
/// **Example:**
/// ```rust
/// [0..].iter().zip(infinite_iter.take_while(|x| x > 5))
/// ```
2018-03-28 13:24:26 +00:00
declare_clippy_lint! {
pub MAYBE_INFINITE_ITER,
2018-03-28 13:24:26 +00:00
pedantic,
"possible infinite iteration"
}
#[derive(Copy, Clone)]
pub struct Pass;
impl LintPass for Pass {
fn get_lints(&self) -> LintArray {
lint_array!(INFINITE_ITER, MAYBE_INFINITE_ITER)
}
}
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
let (lint, msg) = match complete_infinite_iter(cx, expr) {
2017-08-26 16:46:42 +00:00
Infinite => (INFINITE_ITER, "infinite iteration detected"),
2017-09-03 21:15:15 +00:00
MaybeInfinite => (MAYBE_INFINITE_ITER, "possible infinite iteration detected"),
Finite => {
return;
},
};
span_lint(cx, lint, expr.span, msg)
}
}
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
2017-08-26 16:46:42 +00:00
enum Finiteness {
Infinite,
MaybeInfinite,
2017-09-03 21:15:15 +00:00
Finite,
}
2017-09-05 09:33:04 +00:00
use self::Finiteness::{Finite, Infinite, MaybeInfinite};
2017-08-26 16:46:42 +00:00
impl Finiteness {
fn and(self, b: Self) -> Self {
match (self, b) {
2017-08-26 16:46:42 +00:00
(Finite, _) | (_, Finite) => Finite,
2017-09-05 09:33:04 +00:00
(MaybeInfinite, _) | (_, MaybeInfinite) => MaybeInfinite,
2017-09-03 21:15:15 +00:00
_ => Infinite,
}
}
fn or(self, b: Self) -> Self {
match (self, b) {
2017-08-26 16:46:42 +00:00
(Infinite, _) | (_, Infinite) => Infinite,
2017-09-05 09:33:04 +00:00
(MaybeInfinite, _) | (_, MaybeInfinite) => MaybeInfinite,
2017-09-03 21:15:15 +00:00
_ => Finite,
}
}
}
2017-08-26 16:46:42 +00:00
impl From<bool> for Finiteness {
fn from(b: bool) -> Self {
2017-09-05 09:33:04 +00:00
if b {
Infinite
} else {
Finite
}
}
}
2017-08-26 16:46:42 +00:00
/// This tells us what to look for to know if the iterator returned by
/// this method is infinite
#[derive(Copy, Clone)]
enum Heuristic {
2017-08-26 16:46:42 +00:00
/// infinite no matter what
Always,
2017-08-26 16:46:42 +00:00
/// infinite if the first argument is
First,
2017-08-26 16:46:42 +00:00
/// infinite if any of the supplied arguments is
Any,
2017-08-26 16:46:42 +00:00
/// infinite if all of the supplied arguments are
2017-09-03 21:15:15 +00:00
All,
}
2017-09-05 09:33:04 +00:00
use self::Heuristic::{All, Always, Any, First};
2017-08-26 16:46:42 +00:00
/// a slice of (method name, number of args, heuristic, bounds) tuples
/// that will be used to determine whether the method in question
/// returns an infinite or possibly infinite iterator. The finiteness
/// is an upper bound, e.g. some methods can return a possibly
/// infinite iterator at worst, e.g. `take_while`.
2017-09-03 21:15:15 +00:00
static HEURISTICS: &[(&str, usize, Heuristic, Finiteness)] = &[
2017-08-26 16:46:42 +00:00
("zip", 2, All, Infinite),
("chain", 2, Any, Infinite),
("cycle", 1, Always, Infinite),
("map", 2, First, Infinite),
("by_ref", 1, First, Infinite),
("cloned", 1, First, Infinite),
("rev", 1, First, Infinite),
("inspect", 1, First, Infinite),
("enumerate", 1, First, Infinite),
("peekable", 2, First, Infinite),
("fuse", 1, First, Infinite),
("skip", 2, First, Infinite),
("skip_while", 1, First, Infinite),
("filter", 2, First, Infinite),
("filter_map", 2, First, Infinite),
("flat_map", 2, First, Infinite),
("unzip", 1, First, Infinite),
("take_while", 2, First, MaybeInfinite),
2017-09-03 21:15:15 +00:00
("scan", 3, First, MaybeInfinite),
];
2018-07-23 11:01:12 +00:00
fn is_infinite(cx: &LateContext<'_, '_>, expr: &Expr) -> Finiteness {
match expr.node {
2018-07-12 07:30:57 +00:00
ExprKind::MethodCall(ref method, _, ref args) => {
for &(name, len, heuristic, cap) in HEURISTICS.iter() {
2018-06-28 13:46:58 +00:00
if method.ident.name == name && args.len() == len {
return (match heuristic {
2017-09-05 09:33:04 +00:00
Always => Infinite,
First => is_infinite(cx, &args[0]),
Any => is_infinite(cx, &args[0]).or(is_infinite(cx, &args[1])),
All => is_infinite(cx, &args[0]).and(is_infinite(cx, &args[1])),
2018-11-27 20:14:15 +00:00
})
.and(cap);
}
}
2018-06-28 13:46:58 +00:00
if method.ident.name == "flat_map" && args.len() == 2 {
2018-07-12 07:30:57 +00:00
if let ExprKind::Closure(_, _, body_id, _, _) = args[1].node {
let body = cx.tcx.hir().body(body_id);
return is_infinite(cx, &body.value);
}
}
2017-08-26 16:46:42 +00:00
Finite
},
2018-07-12 07:30:57 +00:00
ExprKind::Block(ref block, _) => block.expr.as_ref().map_or(Finite, |e| is_infinite(cx, e)),
ExprKind::Box(ref e) | ExprKind::AddrOf(_, ref e) => is_infinite(cx, e),
2018-11-27 20:14:15 +00:00
ExprKind::Call(ref path, _) => {
if let ExprKind::Path(ref qpath) = path.node {
match_qpath(qpath, &paths::REPEAT).into()
} else {
Finite
}
},
2018-11-27 20:14:15 +00:00
ExprKind::Struct(..) => higher::range(cx, expr).map_or(false, |r| r.end.is_none()).into(),
2017-09-03 21:15:15 +00:00
_ => Finite,
}
}
2017-08-26 16:46:42 +00:00
/// the names and argument lengths of methods that *may* exhaust their
/// iterators
2017-09-03 21:15:15 +00:00
static POSSIBLY_COMPLETING_METHODS: &[(&str, usize)] = &[
("find", 2),
("rfind", 2),
("position", 2),
("rposition", 2),
("any", 2),
2017-09-03 21:15:15 +00:00
("all", 2),
];
2017-08-26 16:46:42 +00:00
/// the names and argument lengths of methods that *always* exhaust
/// their iterators
2017-09-03 21:15:15 +00:00
static COMPLETING_METHODS: &[(&str, usize)] = &[
("count", 1),
("fold", 3),
("for_each", 2),
("partition", 2),
("max", 1),
("max_by", 2),
("max_by_key", 2),
("min", 1),
("min_by", 2),
("min_by_key", 2),
("sum", 1),
2017-09-03 21:15:15 +00:00
("product", 1),
];
/// the paths of types that are known to be infinitely allocating
static INFINITE_COLLECTORS: &[&[&str]] = &[
&paths::BINARY_HEAP,
&paths::BTREEMAP,
&paths::BTREESET,
&paths::HASHMAP,
&paths::HASHSET,
&paths::LINKED_LIST,
&paths::VEC,
&paths::VEC_DEQUE,
];
2018-07-23 11:01:12 +00:00
fn complete_infinite_iter(cx: &LateContext<'_, '_>, expr: &Expr) -> Finiteness {
match expr.node {
2018-07-12 07:30:57 +00:00
ExprKind::MethodCall(ref method, _, ref args) => {
for &(name, len) in COMPLETING_METHODS.iter() {
2018-06-28 13:46:58 +00:00
if method.ident.name == name && args.len() == len {
return is_infinite(cx, &args[0]);
}
}
for &(name, len) in POSSIBLY_COMPLETING_METHODS.iter() {
2018-06-28 13:46:58 +00:00
if method.ident.name == name && args.len() == len {
2017-08-26 16:46:42 +00:00
return MaybeInfinite.and(is_infinite(cx, &args[0]));
}
}
2018-06-28 13:46:58 +00:00
if method.ident.name == "last" && args.len() == 1 {
2017-09-05 09:33:04 +00:00
let not_double_ended = get_trait_def_id(cx, &paths::DOUBLE_ENDED_ITERATOR)
.map_or(false, |id| !implements_trait(cx, cx.tables.expr_ty(&args[0]), id, &[]));
2017-09-03 21:58:27 +00:00
if not_double_ended {
2017-09-05 09:33:04 +00:00
return is_infinite(cx, &args[0]);
2017-09-03 21:58:27 +00:00
}
} else if method.ident.name == "collect" {
let ty = cx.tables.expr_ty(expr);
if INFINITE_COLLECTORS.iter().any(|path| match_type(cx, ty, path)) {
return is_infinite(cx, &args[0]);
}
}
},
2018-11-27 20:14:15 +00:00
ExprKind::Binary(op, ref l, ref r) => {
if op.node.is_comparison() {
return is_infinite(cx, l).and(is_infinite(cx, r)).and(MaybeInfinite);
}
2018-07-12 07:30:57 +00:00
}, // TODO: ExprKind::Loop + Match
2017-09-03 21:15:15 +00:00
_ => (),
}
2017-08-26 16:46:42 +00:00
Finite
}