Move `manual_mul_add` into `suboptimal_flops` lint

16 files changed, 179 insertions, 290 deletions

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 87ece835f7f..ce696aa8550 100644
--- a/CHANGELOG.md
+++ b/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
diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index d342afbc12a..fbc375c655e 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/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);
         }
     }
 }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 59ad7e7a651..503eb9ec10d 100644
--- a/clippy_lints/src/lib.rs
+++ b/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),
diff --git a/clippy_lints/src/mul_add.rs b/clippy_lints/src/mul_add.rs
deleted file mode 100644
index 57e56d8f959..00000000000
--- a/clippy_lints/src/mul_add.rs
+++ /dev/null
@@ -1,111 +0,0 @@
-use rustc_errors::Applicability;
-use rustc_hir::{BinOpKind, Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-use crate::utils::{snippet, span_lint_and_sugg};
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for expressions of the form `a * b + c`
-    /// or `c + a * b` where `a`, `b`, `c` are floats and suggests using
-    /// `a.mul_add(b, c)` instead.
-    ///
-    /// **Why is this bad?** Calculating `a * b + c` may lead to slight
-    /// numerical inaccuracies as `a * b` is rounded before being added to
-    /// `c`. Depending on the target architecture, `mul_add()` may be more
-    /// performant.
-    ///
-    /// **Known problems:** This lint can emit semantic incorrect suggestions.
-    /// For example, for `a * b * c + d` the suggestion `a * b.mul_add(c, d)`
-    /// is emitted, which is equivalent to `a * (b * c + d)`. (#4735)
-    ///
-    /// **Example:**
-    ///
-    /// ```rust
-    /// # let a = 0_f32;
-    /// # let b = 0_f32;
-    /// # let c = 0_f32;
-    /// let foo = (a * b) + c;
-    /// ```
-    ///
-    /// can be written as
-    ///
-    /// ```rust
-    /// # let a = 0_f32;
-    /// # let b = 0_f32;
-    /// # let c = 0_f32;
-    /// let foo = a.mul_add(b, c);
-    /// ```
-    pub MANUAL_MUL_ADD,
-    nursery,
-    "Using `a.mul_add(b, c)` for floating points has higher numerical precision than `a * b + c`"
-}
-
-declare_lint_pass!(MulAddCheck => [MANUAL_MUL_ADD]);
-
-fn is_float<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &Expr<'_>) -> bool {
-    cx.tables.expr_ty(expr).is_floating_point()
-}
-
-// Checks whether expression is multiplication of two floats
-fn is_float_mult_expr<'a, 'tcx, 'b>(
-    cx: &LateContext<'a, 'tcx>,
-    expr: &'b Expr<'b>,
-) -> Option<(&'b Expr<'b>, &'b Expr<'b>)> {
-    if let ExprKind::Binary(op, lhs, rhs) = &expr.kind {
-        if let BinOpKind::Mul = op.node {
-            if is_float(cx, &lhs) && is_float(cx, &rhs) {
-                return Some((&lhs, &rhs));
-            }
-        }
-    }
-
-    None
-}
-
-impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MulAddCheck {
-    fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr<'_>) {
-        if let ExprKind::Binary(op, lhs, rhs) = &expr.kind {
-            if let BinOpKind::Add = op.node {
-                //Converts mult_lhs * mult_rhs + rhs to mult_lhs.mult_add(mult_rhs, rhs)
-                if let Some((mult_lhs, mult_rhs)) = is_float_mult_expr(cx, lhs) {
-                    if is_float(cx, rhs) {
-                        span_lint_and_sugg(
-                            cx,
-                            MANUAL_MUL_ADD,
-                            expr.span,
-                            "consider using `mul_add()` for better numerical precision",
-                            "try",
-                            format!(
-                                "{}.mul_add({}, {})",
-                                snippet(cx, mult_lhs.span, "_"),
-                                snippet(cx, mult_rhs.span, "_"),
-                                snippet(cx, rhs.span, "_"),
-                            ),
-                            Applicability::MaybeIncorrect,
-                        );
-                    }
-                }
-                //Converts lhs + mult_lhs * mult_rhs to mult_lhs.mult_add(mult_rhs, lhs)
-                if let Some((mult_lhs, mult_rhs)) = is_float_mult_expr(cx, rhs) {
-                    if is_float(cx, lhs) {
-                        span_lint_and_sugg(
-                            cx,
-                            MANUAL_MUL_ADD,
-                            expr.span,
-                            "consider using `mul_add()` for better numerical precision",
-                            "try",
-                            format!(
-                                "{}.mul_add({}, {})",
-                                snippet(cx, mult_lhs.span, "_"),
-                                snippet(cx, mult_rhs.span, "_"),
-                                snippet(cx, lhs.span, "_"),
-                            ),
-                            Applicability::MaybeIncorrect,
-                        );
-                    }
-                }
-            }
-        }
-    }
-}
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index de086f863e0..5b4aad347af 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1023,13 +1023,6 @@ pub const ALL_LINTS: [Lint; 357] = [
         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",
         desc: "`.chcked_add/sub(x).unwrap_or(MAX/MIN)`",
diff --git a/tests/ui/floating_point_fma.fixed b/tests/ui/floating_point_fma.fixed
new file mode 100644
index 00000000000..e343c37740d
--- /dev/null
+++ b/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.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);
+}
diff --git a/tests/ui/floating_point_fma.rs b/tests/ui/floating_point_fma.rs
new file mode 100644
index 00000000000..810f929c856
--- /dev/null
+++ b/tests/ui/floating_point_fma.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 * 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;
+}
diff --git a/tests/ui/floating_point_fma.stderr b/tests/ui/floating_point_fma.stderr
new file mode 100644
index 00000000000..5c653360ebc
--- /dev/null
+++ b/tests/ui/floating_point_fma.stderr
@@ -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
+
diff --git a/tests/ui/floating_point_log.fixed b/tests/ui/floating_point_log.fixed
index ead45fc4a9f..afe72a8dd11 100644
--- a/tests/ui/floating_point_log.fixed
+++ b/tests/ui/floating_point_log.fixed
@@ -24,34 +24,34 @@ fn check_ln1p() {
     let _ = 2.0f32.ln_1p();
     let _ = 2.0f32.ln_1p();
     let _ = x.ln_1p();
-    let _ = (x * 2.0).ln_1p();
+    let _ = (x / 2.0).ln_1p();
     let _ = x.powi(2).ln_1p();
-    let _ = (x.powi(2) * 2.0).ln_1p();
+    let _ = (x.powi(2) / 2.0).ln_1p();
     let _ = ((std::f32::consts::E - 1.0)).ln_1p();
     let _ = x.ln_1p();
     let _ = x.powi(2).ln_1p();
     let _ = (x + 2.0).ln_1p();
-    let _ = (x * 2.0).ln_1p();
+    let _ = (x / 2.0).ln_1p();
     // Cases where the lint shouldn't be applied
     let _ = (1.0 + x + 2.0).ln();
     let _ = (x + 1.0 + 2.0).ln();
-    let _ = (x + 1.0 * 2.0).ln();
+    let _ = (x + 1.0 / 2.0).ln();
     let _ = (1.0 + x - 2.0).ln();
 
     let x = 1f64;
     let _ = 2.0f64.ln_1p();
     let _ = 2.0f64.ln_1p();
     let _ = x.ln_1p();
-    let _ = (x * 2.0).ln_1p();
+    let _ = (x / 2.0).ln_1p();
     let _ = x.powi(2).ln_1p();
     let _ = x.ln_1p();
     let _ = x.powi(2).ln_1p();
     let _ = (x + 2.0).ln_1p();
-    let _ = (x * 2.0).ln_1p();
+    let _ = (x / 2.0).ln_1p();
     // Cases where the lint shouldn't be applied
     let _ = (1.0 + x + 2.0).ln();
     let _ = (x + 1.0 + 2.0).ln();
-    let _ = (x + 1.0 * 2.0).ln();
+    let _ = (x + 1.0 / 2.0).ln();
     let _ = (1.0 + x - 2.0).ln();
 }
 
diff --git a/tests/ui/floating_point_log.rs b/tests/ui/floating_point_log.rs
index f888e1375dc..785b5a3bc48 100644
--- a/tests/ui/floating_point_log.rs
+++ b/tests/ui/floating_point_log.rs
@@ -24,34 +24,34 @@ fn check_ln1p() {
     let _ = (1f32 + 2.).ln();
     let _ = (1f32 + 2.0).ln();
     let _ = (1.0 + x).ln();
-    let _ = (1.0 + x * 2.0).ln();
+    let _ = (1.0 + x / 2.0).ln();
     let _ = (1.0 + x.powi(2)).ln();
-    let _ = (1.0 + x.powi(2) * 2.0).ln();
+    let _ = (1.0 + x.powi(2) / 2.0).ln();
     let _ = (1.0 + (std::f32::consts::E - 1.0)).ln();
     let _ = (x + 1.0).ln();
     let _ = (x.powi(2) + 1.0).ln();
     let _ = (x + 2.0 + 1.0).ln();
-    let _ = (x * 2.0 + 1.0).ln();
+    let _ = (x / 2.0 + 1.0).ln();
     // Cases where the lint shouldn't be applied
     let _ = (1.0 + x + 2.0).ln();
     let _ = (x + 1.0 + 2.0).ln();
-    let _ = (x + 1.0 * 2.0).ln();
+    let _ = (x + 1.0 / 2.0).ln();
     let _ = (1.0 + x - 2.0).ln();
 
     let x = 1f64;
     let _ = (1f64 + 2.).ln();
     let _ = (1f64 + 2.0).ln();
     let _ = (1.0 + x).ln();
-    let _ = (1.0 + x * 2.0).ln();
+    let _ = (1.0 + x / 2.0).ln();
     let _ = (1.0 + x.powi(2)).ln();
     let _ = (x + 1.0).ln();
     let _ = (x.powi(2) + 1.0).ln();
     let _ = (x + 2.0 + 1.0).ln();
-    let _ = (x * 2.0 + 1.0).ln();
+    let _ = (x / 2.0 + 1.0).ln();
     // Cases where the lint shouldn't be applied
     let _ = (1.0 + x + 2.0).ln();
     let _ = (x + 1.0 + 2.0).ln();
-    let _ = (x + 1.0 * 2.0).ln();
+    let _ = (x + 1.0 / 2.0).ln();
     let _ = (1.0 + x - 2.0).ln();
 }
 
diff --git a/tests/ui/floating_point_log.stderr b/tests/ui/floating_point_log.stderr
index c8c32b61ca3..cb0bb6d652a 100644
--- a/tests/ui/floating_point_log.stderr
+++ b/tests/ui/floating_point_log.stderr
@@ -69,8 +69,8 @@ LL |     let _ = (1.0 + x).ln();
 error: ln(1 + x) can be computed more accurately
   --> $DIR/floating_point_log.rs:27:13
    |
-LL |     let _ = (1.0 + x * 2.0).ln();
-   |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x * 2.0).ln_1p()`
+LL |     let _ = (1.0 + x / 2.0).ln();
+   |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x / 2.0).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
   --> $DIR/floating_point_log.rs:28:13
@@ -81,8 +81,8 @@ LL |     let _ = (1.0 + x.powi(2)).ln();
 error: ln(1 + x) can be computed more accurately
   --> $DIR/floating_point_log.rs:29:13
    |
-LL |     let _ = (1.0 + x.powi(2) * 2.0).ln();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x.powi(2) * 2.0).ln_1p()`
+LL |     let _ = (1.0 + x.powi(2) / 2.0).ln();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x.powi(2) / 2.0).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
   --> $DIR/floating_point_log.rs:30:13
@@ -111,8 +111,8 @@ LL |     let _ = (x + 2.0 + 1.0).ln();
 error: ln(1 + x) can be computed more accurately
   --> $DIR/floating_point_log.rs:34:13
    |
-LL |     let _ = (x * 2.0 + 1.0).ln();
-   |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x * 2.0).ln_1p()`
+LL |     let _ = (x / 2.0 + 1.0).ln();
+   |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x / 2.0).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
   --> $DIR/floating_point_log.rs:42:13
@@ -135,8 +135,8 @@ LL |     let _ = (1.0 + x).ln();
 error: ln(1 + x) can be computed more accurately
   --> $DIR/floating_point_log.rs:45:13
    |
-LL |     let _ = (1.0 + x * 2.0).ln();
-   |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x * 2.0).ln_1p()`
+LL |     let _ = (1.0 + x / 2.0).ln();
+   |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x / 2.0).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
   --> $DIR/floating_point_log.rs:46:13
@@ -165,8 +165,8 @@ LL |     let _ = (x + 2.0 + 1.0).ln();
 error: ln(1 + x) can be computed more accurately
   --> $DIR/floating_point_log.rs:50:13
    |
-LL |     let _ = (x * 2.0 + 1.0).ln();
-   |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x * 2.0).ln_1p()`
+LL |     let _ = (x / 2.0 + 1.0).ln();
+   |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x / 2.0).ln_1p()`
 
 error: aborting due to 28 previous errors
 
diff --git a/tests/ui/mul_add.rs b/tests/ui/mul_add.rs
deleted file mode 100644
index 1322e002c64..00000000000
--- a/tests/ui/mul_add.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-#![warn(clippy::manual_mul_add)]
-#![allow(unused_variables)]
-
-fn mul_add_test() {
-    let a: f64 = 1234.567;
-    let b: f64 = 45.67834;
-    let c: f64 = 0.0004;
-
-    // Examples of not auto-fixable expressions
-    let test1 = (a * b + c) * (c + a * b) + (c + (a * b) + c);
-    let test2 = 1234.567 * 45.67834 + 0.0004;
-}
-
-fn main() {
-    mul_add_test();
-}
diff --git a/tests/ui/mul_add.stderr b/tests/ui/mul_add.stderr
deleted file mode 100644
index 3b21646f7c3..00000000000
--- a/tests/ui/mul_add.stderr
+++ /dev/null
@@ -1,34 +0,0 @@
-error: consider using `mul_add()` for better numerical precision
-  --> $DIR/mul_add.rs:10:17
-   |
-LL |     let test1 = (a * b + c) * (c + a * b) + (c + (a * b) + c);
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(a * b + c).mul_add((c + a * b), (c + (a * b) + c))`
-   |
-   = note: `-D clippy::manual-mul-add` implied by `-D warnings`
-
-error: consider using `mul_add()` for better numerical precision
-  --> $DIR/mul_add.rs:10:17
-   |
-LL |     let test1 = (a * b + c) * (c + a * b) + (c + (a * b) + c);
-   |                 ^^^^^^^^^^^ help: try: `a.mul_add(b, c)`
-
-error: consider using `mul_add()` for better numerical precision
-  --> $DIR/mul_add.rs:10:31
-   |
-LL |     let test1 = (a * b + c) * (c + a * b) + (c + (a * b) + c);
-   |                               ^^^^^^^^^^^ help: try: `a.mul_add(b, c)`
-
-error: consider using `mul_add()` for better numerical precision
-  --> $DIR/mul_add.rs:10:46
-   |
-LL |     let test1 = (a * b + c) * (c + a * b) + (c + (a * b) + c);
-   |                                              ^^^^^^^^^^^ help: try: `a.mul_add(b, c)`
-
-error: consider using `mul_add()` for better numerical precision
-  --> $DIR/mul_add.rs:11:17
-   |
-LL |     let test2 = 1234.567 * 45.67834 + 0.0004;
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `1234.567.mul_add(45.67834, 0.0004)`
-
-error: aborting due to 5 previous errors
-
diff --git a/tests/ui/mul_add_fixable.fixed b/tests/ui/mul_add_fixable.fixed
deleted file mode 100644
index 4af7c7e3e1a..00000000000
--- a/tests/ui/mul_add_fixable.fixed
+++ /dev/null
@@ -1,24 +0,0 @@
-// run-rustfix
-
-#![warn(clippy::manual_mul_add)]
-#![allow(unused_variables)]
-
-fn mul_add_test() {
-    let a: f64 = 1234.567;
-    let b: f64 = 45.67834;
-    let c: f64 = 0.0004;
-
-    // Auto-fixable examples
-    let test1 = a.mul_add(b, c);
-    let test2 = a.mul_add(b, c);
-
-    let test3 = a.mul_add(b, c);
-    let test4 = a.mul_add(b, c);
-
-    let test5 = a.mul_add(b, c).mul_add(a.mul_add(b, c), a.mul_add(b, c)) + c;
-    let test6 = 1234.567_f64.mul_add(45.67834_f64, 0.0004_f64);
-}
-
-fn main() {
-    mul_add_test();
-}
diff --git a/tests/ui/mul_add_fixable.rs b/tests/ui/mul_add_fixable.rs
deleted file mode 100644
index 8b42f6f184a..00000000000
--- a/tests/ui/mul_add_fixable.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-// run-rustfix
-
-#![warn(clippy::manual_mul_add)]
-#![allow(unused_variables)]
-
-fn mul_add_test() {
-    let a: f64 = 1234.567;
-    let b: f64 = 45.67834;
-    let c: f64 = 0.0004;
-
-    // Auto-fixable examples
-    let test1 = a * b + c;
-    let test2 = c + a * b;
-
-    let test3 = (a * b) + c;
-    let test4 = c + (a * b);
-
-    let test5 = a.mul_add(b, c) * a.mul_add(b, c) + a.mul_add(b, c) + c;
-    let test6 = 1234.567_f64 * 45.67834_f64 + 0.0004_f64;
-}
-
-fn main() {
-    mul_add_test();
-}
diff --git a/tests/ui/mul_add_fixable.stderr b/tests/ui/mul_add_fixable.stderr
deleted file mode 100644
index 235443f4b02..00000000000
--- a/tests/ui/mul_add_fixable.stderr
+++ /dev/null
@@ -1,40 +0,0 @@
-error: consider using `mul_add()` for better numerical precision
-  --> $DIR/mul_add_fixable.rs:12:17
-   |
-LL |     let test1 = a * b + c;
-   |                 ^^^^^^^^^ help: try: `a.mul_add(b, c)`
-   |
-   = note: `-D clippy::manual-mul-add` implied by `-D warnings`
-
-error: consider using `mul_add()` for better numerical precision
-  --> $DIR/mul_add_fixable.rs:13:17
-   |
-LL |     let test2 = c + a * b;
-   |                 ^^^^^^^^^ help: try: `a.mul_add(b, c)`
-
-error: consider using `mul_add()` for better numerical precision
-  --> $DIR/mul_add_fixable.rs:15:17
-   |
-LL |     let test3 = (a * b) + c;
-   |                 ^^^^^^^^^^^ help: try: `a.mul_add(b, c)`
-
-error: consider using `mul_add()` for better numerical precision
-  --> $DIR/mul_add_fixable.rs:16:17
-   |
-LL |     let test4 = c + (a * b);
-   |                 ^^^^^^^^^^^ help: try: `a.mul_add(b, c)`
-
-error: consider using `mul_add()` for better numerical precision
-  --> $DIR/mul_add_fixable.rs:18:17
-   |
-LL |     let test5 = a.mul_add(b, c) * a.mul_add(b, c) + a.mul_add(b, c) + c;
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `a.mul_add(b, c).mul_add(a.mul_add(b, c), a.mul_add(b, c))`
-
-error: consider using `mul_add()` for better numerical precision
-  --> $DIR/mul_add_fixable.rs:19:17
-   |
-LL |     let test6 = 1234.567_f64 * 45.67834_f64 + 0.0004_f64;
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `1234.567_f64.mul_add(45.67834_f64, 0.0004_f64)`
-
-error: aborting due to 6 previous errors
-