2024-03-21 16:20:40 -05:00
|
|
|
use clippy_utils::diagnostics::{multispan_sugg_with_applicability, span_lint_hir_and_then};
|
|
|
|
use clippy_utils::source::{snippet, snippet_opt};
|
2024-05-02 10:26:44 -05:00
|
|
|
use clippy_utils::{expr_or_init, is_trait_method, pat_is_wild};
|
2024-03-21 16:20:40 -05:00
|
|
|
use rustc_errors::Applicability;
|
|
|
|
use rustc_hir::{Expr, ExprKind, FnDecl, PatKind, TyKind};
|
|
|
|
use rustc_lint::LateContext;
|
|
|
|
use rustc_middle::ty::AdtDef;
|
|
|
|
use rustc_span::{sym, Span};
|
|
|
|
|
|
|
|
use crate::loops::UNUSED_ENUMERATE_INDEX;
|
|
|
|
|
|
|
|
/// Check for the `UNUSED_ENUMERATE_INDEX` lint outside of loops.
|
|
|
|
///
|
|
|
|
/// The lint is declared in `clippy_lints/src/loops/mod.rs`. There, the following pattern is
|
|
|
|
/// checked:
|
|
|
|
/// ```ignore
|
|
|
|
/// for (_, x) in some_iter.enumerate() {
|
|
|
|
/// // Index is ignored
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// This `check` function checks for chained method calls constructs where we can detect that the
|
|
|
|
/// index is unused. Currently, this checks only for the following patterns:
|
|
|
|
/// ```ignore
|
|
|
|
/// some_iter.enumerate().map_function(|(_, x)| ..)
|
|
|
|
/// let x = some_iter.enumerate();
|
|
|
|
/// x.map_function(|(_, x)| ..)
|
|
|
|
/// ```
|
|
|
|
/// where `map_function` is one of `all`, `any`, `filter_map`, `find_map`, `flat_map`, `for_each` or
|
|
|
|
/// `map`.
|
|
|
|
///
|
|
|
|
/// # Preconditions
|
|
|
|
/// This function must be called not on the `enumerate` call expression itself, but on any of the
|
|
|
|
/// map functions listed above. It will ensure that `recv` is a `std::iter::Enumerate` instance and
|
|
|
|
/// that the method call is one of the `std::iter::Iterator` trait.
|
|
|
|
///
|
|
|
|
/// * `call_expr`: The map function call expression
|
|
|
|
/// * `recv`: The receiver of the call
|
|
|
|
/// * `closure_arg`: The argument to the map function call containing the closure/function to apply
|
|
|
|
pub(super) fn check(cx: &LateContext<'_>, call_expr: &Expr<'_>, recv: &Expr<'_>, closure_arg: &Expr<'_>) {
|
|
|
|
let recv_ty = cx.typeck_results().expr_ty(recv);
|
|
|
|
if let Some(recv_ty_defid) = recv_ty.ty_adt_def().map(AdtDef::did)
|
|
|
|
// If we call a method on a `std::iter::Enumerate` instance
|
2024-05-02 10:26:44 -05:00
|
|
|
&& cx.tcx.is_diagnostic_item(sym::Enumerate, recv_ty_defid)
|
2024-03-21 16:20:40 -05:00
|
|
|
// If we are calling a method of the `Iterator` trait
|
|
|
|
&& is_trait_method(cx, call_expr, sym::Iterator)
|
|
|
|
// And the map argument is a closure
|
|
|
|
&& let ExprKind::Closure(closure) = closure_arg.kind
|
|
|
|
&& let closure_body = cx.tcx.hir().body(closure.body)
|
|
|
|
// And that closure has one argument ...
|
|
|
|
&& let [closure_param] = closure_body.params
|
|
|
|
// .. which is a tuple of 2 elements
|
|
|
|
&& let PatKind::Tuple([index, elem], ..) = closure_param.pat.kind
|
|
|
|
// And that the first element (the index) is either `_` or unused in the body
|
|
|
|
&& pat_is_wild(cx, &index.kind, closure_body)
|
|
|
|
// Try to find the initializer for `recv`. This is needed in case `recv` is a local_binding. In the
|
|
|
|
// first example below, `expr_or_init` would return `recv`.
|
|
|
|
// ```
|
|
|
|
// iter.enumerate().map(|(_, x)| x)
|
|
|
|
// ^^^^^^^^^^^^^^^^ `recv`, a call to `std::iter::Iterator::enumerate`
|
|
|
|
//
|
|
|
|
// let binding = iter.enumerate();
|
|
|
|
// ^^^^^^^^^^^^^^^^ `recv_init_expr`
|
|
|
|
// binding.map(|(_, x)| x)
|
|
|
|
// ^^^^^^^ `recv`, not a call to `std::iter::Iterator::enumerate`
|
|
|
|
// ```
|
|
|
|
&& let recv_init_expr = expr_or_init(cx, recv)
|
|
|
|
// Make sure the initializer is a method call. It may be that the `Enumerate` comes from something
|
|
|
|
// that we cannot control.
|
|
|
|
// This would for instance happen with:
|
|
|
|
// ```
|
|
|
|
// external_lib::some_function_returning_enumerate().map(|(_, x)| x)
|
|
|
|
// ```
|
|
|
|
&& let ExprKind::MethodCall(_, enumerate_recv, _, enumerate_span) = recv_init_expr.kind
|
|
|
|
&& let Some(enumerate_defid) = cx.typeck_results().type_dependent_def_id(recv_init_expr.hir_id)
|
|
|
|
// Make sure the method call is `std::iter::Iterator::enumerate`.
|
2024-05-02 10:26:44 -05:00
|
|
|
&& cx.tcx.is_diagnostic_item(sym::enumerate_method, enumerate_defid)
|
2024-03-21 16:20:40 -05:00
|
|
|
{
|
|
|
|
// Check if the tuple type was explicit. It may be the type system _needs_ the type of the element
|
2024-05-02 10:26:44 -05:00
|
|
|
// that would be explicitly in the closure.
|
2024-03-21 16:20:40 -05:00
|
|
|
let new_closure_param = match find_elem_explicit_type_span(closure.fn_decl) {
|
|
|
|
// We have an explicit type. Get its snippet, that of the binding name, and do `binding: ty`.
|
|
|
|
// Fallback to `..` if we fail getting either snippet.
|
|
|
|
Some(ty_span) => snippet_opt(cx, elem.span)
|
|
|
|
.and_then(|binding_name| snippet_opt(cx, ty_span).map(|ty_name| format!("{binding_name}: {ty_name}")))
|
|
|
|
.unwrap_or_else(|| "..".to_string()),
|
|
|
|
// Otherwise, we have no explicit type. We can replace with the binding name of the element.
|
|
|
|
None => snippet(cx, elem.span, "..").into_owned(),
|
|
|
|
};
|
|
|
|
|
|
|
|
// Suggest removing the tuple from the closure and the preceding call to `enumerate`, whose span we
|
|
|
|
// can get from the `MethodCall`.
|
|
|
|
span_lint_hir_and_then(
|
|
|
|
cx,
|
|
|
|
UNUSED_ENUMERATE_INDEX,
|
|
|
|
recv_init_expr.hir_id,
|
|
|
|
enumerate_span,
|
|
|
|
"you seem to use `.enumerate()` and immediately discard the index",
|
|
|
|
|diag| {
|
|
|
|
multispan_sugg_with_applicability(
|
|
|
|
diag,
|
|
|
|
"remove the `.enumerate()` call",
|
|
|
|
Applicability::MachineApplicable,
|
|
|
|
vec![
|
|
|
|
(closure_param.span, new_closure_param),
|
|
|
|
(
|
|
|
|
enumerate_span.with_lo(enumerate_recv.span.source_callsite().hi()),
|
|
|
|
String::new(),
|
|
|
|
),
|
|
|
|
],
|
|
|
|
);
|
|
|
|
},
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Find the span of the explicit type of the element.
|
|
|
|
///
|
|
|
|
/// # Returns
|
|
|
|
/// If the tuple argument:
|
|
|
|
/// * Has no explicit type, returns `None`
|
|
|
|
/// * Has an explicit tuple type with an implicit element type (`(usize, _)`), returns `None`
|
|
|
|
/// * Has an explicit tuple type with an explicit element type (`(_, i32)`), returns the span for
|
|
|
|
/// the element type.
|
|
|
|
fn find_elem_explicit_type_span(fn_decl: &FnDecl<'_>) -> Option<Span> {
|
|
|
|
if let [tuple_ty] = fn_decl.inputs
|
|
|
|
&& let TyKind::Tup([_idx_ty, elem_ty]) = tuple_ty.kind
|
|
|
|
&& !matches!(elem_ty.kind, TyKind::Err(..) | TyKind::Infer)
|
|
|
|
{
|
|
|
|
Some(elem_ty.span)
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
}
|