Move manual_mul_add into suboptimal_flops lint

Author: krishna-veerareddy

CHANGELOG.md

@@ -1210,7 +1210,6 @@ Released 2018-09-13
 [`lossy_float_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#lossy_float_literal
 [`main_recursion`]: https://rust-lang.github.io/rust-clippy/master/index.html#main_recursion
 [`manual_memcpy`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_memcpy
-[`manual_mul_add`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_mul_add
 [`manual_saturating_arithmetic`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_saturating_arithmetic
 [`manual_swap`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_swap
 [`many_single_char_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#many_single_char_names

clippy_lints/src/floating_point_arithmetic.rs

@@ -2,11 +2,11 @@ use crate::consts::{
     constant, Constant,
     Constant::{F32, F64},
 };
-use crate::utils::*;
+use crate::utils::{span_lint_and_sugg, sugg};
 use if_chain::if_chain;
 use rustc::ty;
 use rustc_errors::Applicability;
-use rustc_hir::*;
+use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use std::f32::consts as f32_consts;
@@ -39,6 +39,7 @@ declare_clippy_lint! {
     /// let _ = (1.0 + a).ln();
     /// let _ = a.exp() - 1.0;
     /// let _ = a.powf(2.0);
+    /// let _ = a * 2.0 + 4.0;
     /// ```
     ///
     /// is better expressed as
@@ -57,6 +58,7 @@ declare_clippy_lint! {
     /// let _ = a.ln_1p();
     /// let _ = a.exp_m1();
     /// let _ = a.powi(2);
+    /// let _ = a.mul_add(2.0, 4.0);
     /// ```
     pub SUBOPTIMAL_FLOPS,
     nursery,
@@ -211,12 +213,12 @@ fn check_powf(cx: &LateContext<'_, '_>, expr: &Expr<'_>, args: &[Expr<'_>]) {
         let (help, suggestion) = if F32(1.0 / 2.0) == value || F64(1.0 / 2.0) == value {
             (
                 "square-root of a number can be computed more efficiently and accurately",
-                format!("{}.sqrt()", Sugg::hir(cx, &args[0], ".."))
+                format!("{}.sqrt()", Sugg::hir(cx, &args[0], "..")),
             )
         } else if F32(1.0 / 3.0) == value || F64(1.0 / 3.0) == value {
             (
                 "cube-root of a number can be computed more accurately",
-                format!("{}.cbrt()", Sugg::hir(cx, &args[0], ".."))
+                format!("{}.cbrt()", Sugg::hir(cx, &args[0], "..")),
             )
         } else if let Some(exponent) = get_integer_from_float_constant(&value) {
             (
@@ -225,7 +227,7 @@ fn check_powf(cx: &LateContext<'_, '_>, expr: &Expr<'_>, args: &[Expr<'_>]) {
                     "{}.powi({})",
                     Sugg::hir(cx, &args[0], ".."),
                     format_numeric_literal(&exponent.to_string(), None, false)
-                )
+                ),
             )
         } else {
             return;
@@ -272,6 +274,52 @@ fn check_expm1(cx: &LateContext<'_, '_>, expr: &Expr<'_>) {
     }
 }
 
+fn is_float_mul_expr<'a>(cx: &LateContext<'_, '_>, expr: &'a Expr<'a>) -> Option<(&'a Expr<'a>, &'a Expr<'a>)> {
+    if_chain! {
+        if let ExprKind::Binary(op, ref lhs, ref rhs) = &expr.kind;
+        if let BinOpKind::Mul = op.node;
+        if cx.tables.expr_ty(lhs).is_floating_point();
+        if cx.tables.expr_ty(rhs).is_floating_point();
+        then {
+            return Some((lhs, rhs));
+        }
+    }
+
+    None
+}
+
+// TODO: Fix rust-lang/rust-clippy#4735
+fn check_fma(cx: &LateContext<'_, '_>, expr: &Expr<'_>) {
+    if_chain! {
+        if let ExprKind::Binary(op, lhs, rhs) = &expr.kind;
+        if let BinOpKind::Add = op.node;
+        then {
+            let (recv, arg1, arg2) = if let Some((inner_lhs, inner_rhs)) = is_float_mul_expr(cx, lhs) {
+                (inner_lhs, inner_rhs, rhs)
+            } else if let Some((inner_lhs, inner_rhs)) = is_float_mul_expr(cx, rhs) {
+                (inner_lhs, inner_rhs, lhs)
+            } else {
+                return;
+            };
+
+            span_lint_and_sugg(
+                cx,
+                SUBOPTIMAL_FLOPS,
+                expr.span,
+                "multiply and add expressions can be calculated more efficiently and accurately",
+                "consider using",
+                format!(
+                    "{}.mul_add({}, {})",
+                    prepare_receiver_sugg(cx, recv),
+                    Sugg::hir(cx, arg1, ".."),
+                    Sugg::hir(cx, arg2, ".."),
+                ),
+                Applicability::MachineApplicable,
+            );
+        }
+    }
+}
+
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for FloatingPointArithmetic {
     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr<'_>) {
         if let ExprKind::MethodCall(ref path, _, args) = &expr.kind {
@@ -287,6 +335,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for FloatingPointArithmetic {
             }
         } else {
             check_expm1(cx, expr);
+            check_fma(cx, expr);
         }
     }
 }

clippy_lints/src/lib.rs

@@ -208,6 +208,7 @@ pub mod exit;
 pub mod explicit_write;
 pub mod fallible_impl_from;
 pub mod float_literal;
+pub mod floating_point_arithmetic;
 pub mod format;
 pub mod formatting;
 pub mod functions;
@@ -248,7 +249,6 @@ pub mod missing_const_for_fn;
 pub mod missing_doc;
 pub mod missing_inline;
 pub mod modulo_arithmetic;
-pub mod mul_add;
 pub mod multiple_crate_versions;
 pub mod mut_key;
 pub mod mut_mut;
@@ -691,7 +691,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS,
         &missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS,
         &modulo_arithmetic::MODULO_ARITHMETIC,
-        &mul_add::MANUAL_MUL_ADD,
         &multiple_crate_versions::MULTIPLE_CRATE_VERSIONS,
         &mut_key::MUTABLE_KEY_TYPE,
         &mut_mut::MUT_MUT,
@@ -967,7 +966,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box inherent_to_string::InherentToString);
     store.register_late_pass(|| box trait_bounds::TraitBounds);
     store.register_late_pass(|| box comparison_chain::ComparisonChain);
-    store.register_late_pass(|| box mul_add::MulAddCheck);
     store.register_late_pass(|| box mut_key::MutableKeyType);
     store.register_late_pass(|| box modulo_arithmetic::ModuloArithmetic);
     store.register_early_pass(|| box reference::DerefAddrOf);
@@ -1652,7 +1650,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&fallible_impl_from::FALLIBLE_IMPL_FROM),
         LintId::of(&floating_point_arithmetic::SUBOPTIMAL_FLOPS),
         LintId::of(&missing_const_for_fn::MISSING_CONST_FOR_FN),
-        LintId::of(&mul_add::MANUAL_MUL_ADD),
         LintId::of(&mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL),
         LintId::of(&mutex_atomic::MUTEX_INTEGER),
         LintId::of(&needless_borrow::NEEDLESS_BORROW),

clippy_lints/src/mul_add.rs

@@ -1022,13 +1022,6 @@ pub const ALL_LINTS: [Lint; 357] = [
         deprecation: None,
         module: "loops",
     },
-    Lint {
-        name: "manual_mul_add",
-        group: "nursery",
-        desc: "Using `a.mul_add(b, c)` for floating points has higher numerical precision than `a * b + c`",
-        deprecation: None,
-        module: "mul_add",
-    },
     Lint {
         name: "manual_saturating_arithmetic",
         group: "style",

src/lintlist/mod.rs

@@ -0,0 +1,21 @@
+// run-rustfix
+#![warn(clippy::suboptimal_flops)]
+
+fn main() {
+    let a: f64 = 1234.567;
+    let b: f64 = 45.67834;
+    let c: f64 = 0.0004;
+    let d: f64 = 0.0001;
+
+    let _ = a.mul_add(b, c);
+    let _ = a.mul_add(b, c);
+    let _ = 2.0f64.mul_add(4.0, a);
+    let _ = 2.0f64.mul_add(4., a);
+
+    let _ = a.mul_add(b, c);
+    let _ = a.mul_add(b, c);
+    let _ = (a * b).mul_add(c, d);
+
+    let _ = a.mul_add(b, c).mul_add(a.mul_add(b, c), a.mul_add(b, c)) + c;
+    let _ = 1234.567_f64.mul_add(45.67834_f64, 0.0004_f64);
+}

tests/ui/floating_point_fma.fixed

@@ -0,0 +1,21 @@
+// run-rustfix
+#![warn(clippy::suboptimal_flops)]
+
+fn main() {
+    let a: f64 = 1234.567;
+    let b: f64 = 45.67834;
+    let c: f64 = 0.0004;
+    let d: f64 = 0.0001;
+
+    let _ = a * b + c;
+    let _ = c + a * b;
+    let _ = a + 2.0 * 4.0;
+    let _ = a + 2. * 4.;
+
+    let _ = (a * b) + c;
+    let _ = c + (a * b);
+    let _ = a * b * c + d;
+
+    let _ = a.mul_add(b, c) * a.mul_add(b, c) + a.mul_add(b, c) + c;
+    let _ = 1234.567_f64 * 45.67834_f64 + 0.0004_f64;
+}

tests/ui/floating_point_fma.rs

@@ -0,0 +1,58 @@
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> $DIR/floating_point_fma.rs:10:13
+   |
+LL |     let _ = a * b + c;
+   |             ^^^^^^^^^ help: consider using: `a.mul_add(b, c)`
+   |
+   = note: `-D clippy::suboptimal-flops` implied by `-D warnings`
+
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> $DIR/floating_point_fma.rs:11:13
+   |
+LL |     let _ = c + a * b;
+   |             ^^^^^^^^^ help: consider using: `a.mul_add(b, c)`
+
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> $DIR/floating_point_fma.rs:12:13
+   |
+LL |     let _ = a + 2.0 * 4.0;
+   |             ^^^^^^^^^^^^^ help: consider using: `2.0f64.mul_add(4.0, a)`
+
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> $DIR/floating_point_fma.rs:13:13
+   |
+LL |     let _ = a + 2. * 4.;
+   |             ^^^^^^^^^^^ help: consider using: `2.0f64.mul_add(4., a)`
+
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> $DIR/floating_point_fma.rs:15:13
+   |
+LL |     let _ = (a * b) + c;
+   |             ^^^^^^^^^^^ help: consider using: `a.mul_add(b, c)`
+
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> $DIR/floating_point_fma.rs:16:13
+   |
+LL |     let _ = c + (a * b);
+   |             ^^^^^^^^^^^ help: consider using: `a.mul_add(b, c)`
+
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> $DIR/floating_point_fma.rs:17:13
+   |
+LL |     let _ = a * b * c + d;
+   |             ^^^^^^^^^^^^^ help: consider using: `(a * b).mul_add(c, d)`
+
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> $DIR/floating_point_fma.rs:19:13
+   |
+LL |     let _ = a.mul_add(b, c) * a.mul_add(b, c) + a.mul_add(b, c) + c;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `a.mul_add(b, c).mul_add(a.mul_add(b, c), a.mul_add(b, c))`
+
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> $DIR/floating_point_fma.rs:20:13
+   |
+LL |     let _ = 1234.567_f64 * 45.67834_f64 + 0.0004_f64;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `1234.567_f64.mul_add(45.67834_f64, 0.0004_f64)`
+
+error: aborting due to 9 previous errors
+