134 lines
4.6 KiB
Rust
134 lines
4.6 KiB
Rust
use clippy_utils::diagnostics::span_lint_and_then;
|
|
use clippy_utils::{get_trait_def_id, path_res};
|
|
use rustc_ast::BinOpKind;
|
|
use rustc_hir::def::Res;
|
|
use rustc_hir::def_id::{DefId, LocalDefId};
|
|
use rustc_hir::intravisit::FnKind;
|
|
use rustc_hir::{Body, Expr, ExprKind, FnDecl, Item, ItemKind, Node};
|
|
use rustc_lint::{LateContext, LateLintPass};
|
|
use rustc_middle::ty::{self, Ty};
|
|
use rustc_session::declare_lint_pass;
|
|
use rustc_span::{sym, Span};
|
|
|
|
declare_clippy_lint! {
|
|
/// ### What it does
|
|
/// Checks that there isn't an infinite recursion in `PartialEq` trait
|
|
/// implementation.
|
|
///
|
|
/// ### Why is this bad?
|
|
/// This is a hard to find infinite recursion which will crashing any code
|
|
/// using it.
|
|
///
|
|
/// ### Example
|
|
/// ```no_run
|
|
/// enum Foo {
|
|
/// A,
|
|
/// B,
|
|
/// }
|
|
///
|
|
/// impl PartialEq for Foo {
|
|
/// fn eq(&self, other: &Self) -> bool {
|
|
/// self == other // bad!
|
|
/// }
|
|
/// }
|
|
/// ```
|
|
/// Use instead:
|
|
///
|
|
/// In such cases, either use `#[derive(PartialEq)]` or don't implement it.
|
|
#[clippy::version = "1.76.0"]
|
|
pub UNCONDITIONAL_RECURSION,
|
|
suspicious,
|
|
"detect unconditional recursion in some traits implementation"
|
|
}
|
|
|
|
declare_lint_pass!(UnconditionalRecursion => [UNCONDITIONAL_RECURSION]);
|
|
|
|
fn get_ty_def_id(ty: Ty<'_>) -> Option<DefId> {
|
|
match ty.peel_refs().kind() {
|
|
ty::Adt(adt, _) => Some(adt.did()),
|
|
ty::Foreign(def_id) => Some(*def_id),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
fn is_local(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
|
|
matches!(path_res(cx, expr), Res::Local(_))
|
|
}
|
|
|
|
impl<'tcx> LateLintPass<'tcx> for UnconditionalRecursion {
|
|
#[allow(clippy::unnecessary_def_path)]
|
|
fn check_fn(
|
|
&mut self,
|
|
cx: &LateContext<'tcx>,
|
|
kind: FnKind<'tcx>,
|
|
_decl: &'tcx FnDecl<'tcx>,
|
|
body: &'tcx Body<'tcx>,
|
|
method_span: Span,
|
|
def_id: LocalDefId,
|
|
) {
|
|
// If the function is a method...
|
|
if let FnKind::Method(name, _) = kind
|
|
// That has two arguments.
|
|
&& let [self_arg, other_arg] = cx
|
|
.tcx
|
|
.instantiate_bound_regions_with_erased(cx.tcx.fn_sig(def_id).skip_binder())
|
|
.inputs()
|
|
&& let Some(self_arg) = get_ty_def_id(*self_arg)
|
|
&& let Some(other_arg) = get_ty_def_id(*other_arg)
|
|
// The two arguments are of the same type.
|
|
&& self_arg == other_arg
|
|
&& let hir_id = cx.tcx.local_def_id_to_hir_id(def_id)
|
|
&& let Some((
|
|
_,
|
|
Node::Item(Item {
|
|
kind: ItemKind::Impl(impl_),
|
|
owner_id,
|
|
..
|
|
}),
|
|
)) = cx.tcx.hir().parent_iter(hir_id).next()
|
|
// We exclude `impl` blocks generated from rustc's proc macros.
|
|
&& !cx.tcx.has_attr(*owner_id, sym::automatically_derived)
|
|
// It is a implementation of a trait.
|
|
&& let Some(trait_) = impl_.of_trait
|
|
&& let Some(trait_def_id) = trait_.trait_def_id()
|
|
// The trait is `PartialEq`.
|
|
&& Some(trait_def_id) == get_trait_def_id(cx, &["core", "cmp", "PartialEq"])
|
|
{
|
|
let to_check_op = if name.name == sym::eq {
|
|
BinOpKind::Eq
|
|
} else {
|
|
BinOpKind::Ne
|
|
};
|
|
let expr = body.value.peel_blocks();
|
|
let is_bad = match expr.kind {
|
|
ExprKind::Binary(op, left, right) if op.node == to_check_op => {
|
|
is_local(cx, left) && is_local(cx, right)
|
|
},
|
|
ExprKind::MethodCall(segment, receiver, &[arg], _) if segment.ident.name == name.name => {
|
|
if is_local(cx, receiver)
|
|
&& is_local(cx, &arg)
|
|
&& let Some(fn_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
|
|
&& let Some(trait_id) = cx.tcx.trait_of_item(fn_id)
|
|
&& trait_id == trait_def_id
|
|
{
|
|
true
|
|
} else {
|
|
false
|
|
}
|
|
},
|
|
_ => false,
|
|
};
|
|
if is_bad {
|
|
span_lint_and_then(
|
|
cx,
|
|
UNCONDITIONAL_RECURSION,
|
|
method_span,
|
|
"function cannot return without recursing",
|
|
|diag| {
|
|
diag.span_note(expr.span, "recursive call site");
|
|
},
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|