use rustc::hir::*;
use rustc::lint::*;
+use rustc::{declare_lint, lint_array};
+use if_chain::if_chain;
use syntax::codemap::{Span, Spanned};
-use consts::{self, Constant};
-use utils::span_lint;
+use crate::consts::{self, Constant};
+use crate::utils::span_lint;
/// **What it does:** Checks for multiplication by -1 as a form of negation.
///
/// ```rust
/// x * -1
/// ```
-declare_lint! {
+declare_clippy_lint! {
pub NEG_MULTIPLY,
- Warn,
+ style,
"multiplying integers with -1"
}
#[allow(match_same_arms)]
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NegMultiply {
fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) {
- if let ExprBinary(Spanned { node: BiMul, .. }, ref l, ref r) = e.node {
+ if let ExprKind::Binary(Spanned { node: BinOpKind::Mul, .. }, ref l, ref r) = e.node {
match (&l.node, &r.node) {
- (&ExprUnary(..), &ExprUnary(..)) => (),
- (&ExprUnary(UnNeg, ref lit), _) => check_mul(cx, e.span, lit, r),
- (_, &ExprUnary(UnNeg, ref lit)) => check_mul(cx, e.span, lit, l),
+ (&ExprKind::Unary(..), &ExprKind::Unary(..)) => (),
+ (&ExprKind::Unary(UnNeg, ref lit), _) => check_mul(cx, e.span, lit, r),
+ (_, &ExprKind::Unary(UnNeg, ref lit)) => check_mul(cx, e.span, lit, l),
_ => (),
}
}
}
fn check_mul(cx: &LateContext, span: Span, lit: &Expr, exp: &Expr) {
- if_let_chain!([
- let ExprLit(ref l) = lit.node,
- let Constant::Int(ref ci) = consts::lit_to_constant(&l.node),
- let Some(val) = ci.to_u64(),
- val == 1,
- cx.tcx.tables().expr_ty(exp).is_integral()
- ], {
- span_lint(cx,
- NEG_MULTIPLY,
- span,
- "Negation by multiplying with -1");
- })
+ if_chain! {
+ if let ExprKind::Lit(ref l) = lit.node;
+ if let Constant::Int(val) = consts::lit_to_constant(&l.node, cx.tables.expr_ty(lit));
+ if val == 1;
+ if cx.tables.expr_ty(exp).is_integral();
+ then {
+ span_lint(cx,
+ NEG_MULTIPLY,
+ span,
+ "Negation by multiplying with -1");
+ }
+ }
}