-use crate::utils::{get_trait_def_id, span_lint};
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::{get_trait_def_id, paths, trait_ref_of_method};
use if_chain::if_chain;
-use rustc::hir;
-use rustc::hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
-use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
-use rustc::{declare_tool_lint, lint_array};
+use rustc_hir as hir;
+use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::hir::map::Map;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
declare_clippy_lint! {
/// **What it does:** Lints for suspicious operations in impls of arithmetic operators, e.g.
"suspicious use of operators in impl of OpAssign trait"
}
-#[derive(Copy, Clone)]
-pub struct SuspiciousImpl;
+declare_lint_pass!(SuspiciousImpl => [SUSPICIOUS_ARITHMETIC_IMPL, SUSPICIOUS_OP_ASSIGN_IMPL]);
-impl LintPass for SuspiciousImpl {
- fn get_lints(&self) -> LintArray {
- lint_array![SUSPICIOUS_ARITHMETIC_IMPL, SUSPICIOUS_OP_ASSIGN_IMPL]
- }
-
- fn name(&self) -> &'static str {
- "SuspiciousImpl"
- }
-}
-
-impl<'a, 'tcx> LateLintPass<'a, 'tcx> for SuspiciousImpl {
- fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) {
- if let hir::ExprKind::Binary(binop, _, _) = expr.node {
+impl<'tcx> LateLintPass<'tcx> for SuspiciousImpl {
+ fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+ if let hir::ExprKind::Binary(binop, _, _) | hir::ExprKind::AssignOp(binop, ..) = expr.kind {
match binop.node {
hir::BinOpKind::Eq
| hir::BinOpKind::Lt
| hir::BinOpKind::Gt => return,
_ => {},
}
- // Check if the binary expression is part of another bi/unary expression
- // as a child node
- let mut parent_expr = cx.tcx.hir().get_parent_node_by_hir_id(expr.hir_id);
- while parent_expr != hir::CRATE_HIR_ID {
- if let hir::Node::Expr(e) = cx.tcx.hir().get_by_hir_id(parent_expr) {
- match e.node {
- hir::ExprKind::Binary(..)
- | hir::ExprKind::Unary(hir::UnOp::UnNot, _)
- | hir::ExprKind::Unary(hir::UnOp::UnNeg, _) => return,
- _ => {},
+
+ // Check for more than one binary operation in the implemented function
+ // Linting when multiple operations are involved can result in false positives
+ let parent_fn = cx.tcx.hir().get_parent_item(expr.hir_id);
+ if_chain! {
+ if let hir::Node::ImplItem(impl_item) = cx.tcx.hir().get(parent_fn);
+ if let hir::ImplItemKind::Fn(_, body_id) = impl_item.kind;
+ then {
+ let body = cx.tcx.hir().body(body_id);
+ let mut visitor = BinaryExprVisitor { nb_binops: 0 };
+ walk_expr(&mut visitor, &body.value);
+ if visitor.nb_binops > 1 {
+ return;
}
}
- parent_expr = cx.tcx.hir().get_parent_node_by_hir_id(parent_expr);
- }
- // as a parent node
- let mut visitor = BinaryExprVisitor { in_binary_expr: false };
- walk_expr(&mut visitor, expr);
-
- if visitor.in_binary_expr {
- return;
}
if let Some(impl_trait) = check_binop(
cx,
expr,
binop.node,
- &["Add", "Sub", "Mul", "Div"],
+ &[
+ "Add", "Sub", "Mul", "Div", "Rem", "BitAnd", "BitOr", "BitXor", "Shl", "Shr",
+ ],
&[
hir::BinOpKind::Add,
hir::BinOpKind::Sub,
hir::BinOpKind::Mul,
hir::BinOpKind::Div,
+ hir::BinOpKind::Rem,
+ hir::BinOpKind::BitAnd,
+ hir::BinOpKind::BitOr,
+ hir::BinOpKind::BitXor,
+ hir::BinOpKind::Shl,
+ hir::BinOpKind::Shr,
],
) {
span_lint(
cx,
SUSPICIOUS_ARITHMETIC_IMPL,
binop.span,
- &format!(r#"Suspicious use of binary operator in `{}` impl"#, impl_trait),
+ &format!("suspicious use of binary operator in `{}` impl", impl_trait),
);
}
cx,
SUSPICIOUS_OP_ASSIGN_IMPL,
binop.span,
- &format!(r#"Suspicious use of binary operator in `{}` impl"#, impl_trait),
+ &format!("suspicious use of binary operator in `{}` impl", impl_trait),
);
}
}
}
}
-fn check_binop<'a>(
- cx: &LateContext<'_, '_>,
- expr: &hir::Expr,
+fn check_binop(
+ cx: &LateContext<'_>,
+ expr: &hir::Expr<'_>,
binop: hir::BinOpKind,
- traits: &[&'a str],
+ traits: &[&'static str],
expected_ops: &[hir::BinOpKind],
-) -> Option<&'a str> {
+) -> Option<&'static str> {
let mut trait_ids = vec![];
- let [krate, module] = crate::utils::paths::OPS_MODULE;
+ let [krate, module] = paths::OPS_MODULE;
- for t in traits {
+ for &t in traits {
let path = [krate, module, t];
if let Some(trait_id) = get_trait_def_id(cx, &path) {
trait_ids.push(trait_id);
// Get the actually implemented trait
let parent_fn = cx.tcx.hir().get_parent_item(expr.hir_id);
- let parent_impl = cx.tcx.hir().get_parent_item(parent_fn);
if_chain! {
- if parent_impl != hir::CRATE_HIR_ID;
- if let hir::Node::Item(item) = cx.tcx.hir().get_by_hir_id(parent_impl);
- if let hir::ItemKind::Impl(_, _, _, _, Some(ref trait_ref), _, _) = item.node;
- if let Some(idx) = trait_ids.iter().position(|&tid| tid == trait_ref.path.def.def_id());
+ if let Some(trait_ref) = trait_ref_of_method(cx, parent_fn);
+ if let Some(idx) = trait_ids.iter().position(|&tid| tid == trait_ref.path.res.def_id());
if binop != expected_ops[idx];
then{
return Some(traits[idx])
}
struct BinaryExprVisitor {
- in_binary_expr: bool,
+ nb_binops: u32,
}
-impl<'a, 'tcx: 'a> Visitor<'tcx> for BinaryExprVisitor {
- fn visit_expr(&mut self, expr: &'tcx hir::Expr) {
- match expr.node {
+impl<'tcx> Visitor<'tcx> for BinaryExprVisitor {
+ type Map = Map<'tcx>;
+
+ fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
+ match expr.kind {
hir::ExprKind::Binary(..)
- | hir::ExprKind::Unary(hir::UnOp::UnNot, _)
- | hir::ExprKind::Unary(hir::UnOp::UnNeg, _) => self.in_binary_expr = true,
+ | hir::ExprKind::Unary(hir::UnOp::Not | hir::UnOp::Neg, _)
+ | hir::ExprKind::AssignOp(..) => self.nb_binops += 1,
_ => {},
}
walk_expr(self, expr);
}
- fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
+
+ fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
NestedVisitorMap::None
}
}
projects / rust.git / blobdiff