`cargo clippy --fix` tries to apply `mul_add` but causes `[E0689]`

[nik-sm]

Summary

I tried enabling additional clippy lints and using --fix on a clean git status, but clippy reports an error and asks me to file a bug report.

Here's what I think happens:

1. Clippy wants to change a line to use mul_add:

// Relevant lines before clippy: 
/* Line 59 */ let multiplier = if first.data > 0.0 { 1.0 } else { 0.0 };
/* Line 60 */ first.grad = Some(first.grad.unwrap_or(0.0) + multiplier * our_grad);

// What clippy wants:
/* Line 59 */ let multiplier = if first.data > 0.0 { 1.0 } else { 0.0 };
/* Line 60 */ first.grad = Some(multiplier.mul_add(our_grad, first.grad.unwrap_or(0.0)));

2. For some reason, clippy's proposed change on line 60 causes an ambiguous type on line 59, which results in a compiler error. Here's the error that clippy causes:

error[E0689]: can't call method `mul_add` on ambiguous numeric type `{float}`
  --> src/main.rs:60:46
   |
60 |                 first.grad = Some(multiplier.mul_add(our_grad, first.grad.unwrap_or(0.0)));
   |                                              ^^^^^^^
   |
help: you must specify a type for this binding, like `f32`
   |
59 |                 let multiplier: f32 = if 2.0 > 0.0 { 1.0 } else { 0.0 };
   |                               +++++

error: aborting due to 1 previous error

Additional observations:

• My rust analyzer VS Code plugin can infer the correct types on line 59 (the multiplier is an f64), even when line 60 is commented out. Here's the details of my rust analyzer plugin:

Identifier rust-lang.rust-analyzer
Version 0.3.2466
Last Updated 2025-05-20, 21:27:47

• Clippy reports the same error twice
• cargo clippy exits without error (which feels like a minor mistake perhaps) and my code ends up unchanged

[nik-sm]

Here's a relatively small example to reproduce the issue. Let me know if additional info would be useful.

% tree 
.
├── Cargo.lock
├── Cargo.toml
└── src
    └── main.rs

Cargo.toml

[package]
name = "tmp"
version = "0.1.0"
edition = "2024"

[dependencies]

[lints.clippy]
nursery = "warn"

src/main.rs

use core::f64;
use std::cell::RefCell;
use std::ops::Deref;
use std::rc::Rc;

pub type FloatDataScalar = f64;
pub type IntDataScalar = i64;
pub type DiscreteLabel = usize;
pub type Dataset<X, Y> = Vec<(X, Y)>;

#[derive(Debug, Clone)]
pub struct ValueInner {
    pub grad: Option<FloatDataScalar>,
    pub backward_fn: Option<fn(&ValueInner)>,
    pub prev_nodes: Option<Vec<Value>>,
}

impl ValueInner {
    pub fn new(prev_nodes: Option<Vec<Value>>, backward_fn: Option<fn(&Self)>) -> Self {
        Self {
            grad: None,
            prev_nodes,
            backward_fn,
        }
    }
}

#[derive(Debug)]
pub struct Value(Rc<RefCell<ValueInner>>);

impl Clone for Value {
    /// To make it super clear that `value.clone()` only increments Rc
    fn clone(&self) -> Self {
        Self(Rc::clone(&self.0))
    }
}

impl Deref for Value {
    type Target = Rc<RefCell<ValueInner>>;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl Value {
    pub fn new(prev_nodes: Option<Vec<Self>>, backward_fn: Option<fn(&ValueInner)>) -> Self {
        Self(Rc::new(RefCell::new(ValueInner::new(
            prev_nodes,
            backward_fn,
        ))))
    }

    pub fn relu(&self) -> Value {
        let prev_nodes = vec![self.clone()];
        let backward_fn = |our_value_inner: &ValueInner| match our_value_inner.prev_nodes.as_deref()
        {
            Some([first]) => {
                let mut first = first.borrow_mut();
                let our_grad = our_value_inner.grad.unwrap_or(0.0);
                let multiplier = if 2.0 > 0.0 { 1.0 } else { 0.0 };
                first.grad = Some(first.grad.unwrap_or(0.0) + multiplier * our_grad);
            }
            _ => {
                unreachable!("relu must have one ancestor")
            }
        };
        Value::new(Some(prev_nodes), Some(backward_fn))
    }
}

fn main() {}

Full output

% cargo clippy --fix
    Checking tmp v0.1.0 (/Users/niklas.smedemark-margulies/Desktop/tmp-cargo-repro/tmp)
warning: failed to automatically apply fixes suggested by rustc to crate `tmp`

after fixes were automatically applied the compiler reported errors within these files:

  * src/main.rs

This likely indicates a bug in either rustc or cargo itself,
and we would appreciate a bug report! You're likely to see
a number of compiler warnings after this message which cargo
attempted to fix but failed. If you could open an issue at
https://github.com/rust-lang/rust-clippy/issues
quoting the full output of this command we'd be very appreciative!
Note that you may be able to make some more progress in the near-term
fixing code with the `--broken-code` flag

The following errors were reported:
error[E0689]: can't call method `mul_add` on ambiguous numeric type `{float}`
  --> src/main.rs:60:46
   |
60 |                 first.grad = Some(multiplier.mul_add(our_grad, first.grad.unwrap_or(0.0)));
   |                                              ^^^^^^^
   |
help: you must specify a type for this binding, like `f32`
   |
59 |                 let multiplier: f32 = if 2.0 > 0.0 { 1.0 } else { 0.0 };
   |                               +++++

error: aborting due to 1 previous error

For more information about this error, try `rustc --explain E0689`.
Original diagnostics will follow.

warning: unnecessary structure name repetition
  --> src/main.rs:52:27
   |
52 |     pub fn relu(&self) -> Value {
   |                           ^^^^^ help: use the applicable keyword: `Self`
   |
   = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#use_self
   = note: `-W clippy::use-self` implied by `-W clippy::nursery`
   = help: to override `-W clippy::nursery` add `#[allow(clippy::use_self)]`

warning: multiply and add expressions can be calculated more efficiently and accurately
  --> src/main.rs:60:35
   |
60 |                 first.grad = Some(first.grad.unwrap_or(0.0) + multiplier * our_grad);
   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `multiplier.mul_add(our_grad, first.grad.unwrap_or(0.0))`
   |
   = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#suboptimal_flops
   = note: `-W clippy::suboptimal-flops` implied by `-W clippy::nursery`
   = help: to override `-W clippy::nursery` add `#[allow(clippy::suboptimal_flops)]`

warning: unnecessary structure name repetition
  --> src/main.rs:66:9
   |
66 |         Value::new(Some(prev_nodes), Some(backward_fn))
   |         ^^^^^ help: use the applicable keyword: `Self`
   |
   = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#use_self

warning: this could be a `const fn`
  --> src/main.rs:70:1
   |
70 | fn main() {}
   | ^^^^^^^^^^^^
   |
   = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#missing_const_for_fn
   = note: `-W clippy::missing-const-for-fn` implied by `-W clippy::nursery`
   = help: to override `-W clippy::nursery` add `#[allow(clippy::missing_const_for_fn)]`
help: make the function `const`
   |
70 | const fn main() {}
   | +++++

warning: `tmp` (bin "tmp" test) generated 4 warnings (run `cargo clippy --fix --bin "tmp" --tests` to apply 4 suggestions)
warning: failed to automatically apply fixes suggested by rustc to crate `tmp`

after fixes were automatically applied the compiler reported errors within these files:

  * src/main.rs

This likely indicates a bug in either rustc or cargo itself,
and we would appreciate a bug report! You're likely to see
a number of compiler warnings after this message which cargo
attempted to fix but failed. If you could open an issue at
https://github.com/rust-lang/rust-clippy/issues
quoting the full output of this command we'd be very appreciative!
Note that you may be able to make some more progress in the near-term
fixing code with the `--broken-code` flag

The following errors were reported:
error[E0689]: can't call method `mul_add` on ambiguous numeric type `{float}`
  --> src/main.rs:60:46
   |
60 |                 first.grad = Some(multiplier.mul_add(our_grad, first.grad.unwrap_or(0.0)));
   |                                              ^^^^^^^
   |
help: you must specify a type for this binding, like `f32`
   |
59 |                 let multiplier: f32 = if 2.0 > 0.0 { 1.0 } else { 0.0 };
   |                               +++++

error: aborting due to 1 previous error

For more information about this error, try `rustc --explain E0689`.
Original diagnostics will follow.

warning: `tmp` (bin "tmp") generated 3 warnings (3 duplicates)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.19s

[nik-sm]

Version

rustc 1.86.0 (05f9846f8 2025-03-31)
binary: rustc
commit-hash: 05f9846f893b09a1be1fc8560e33fc3c815cfecb
commit-date: 2025-03-31
host: aarch64-apple-darwin
release: 1.86.0
LLVM version: 19.1.7

[odysa]

@rustbot claim

[odysa]

Minimal Reproduction:

fn main() {
    let x = 1.0;
    let y = 1.0 + x * 2.0;
    println!("y: {}", y);
}

cargo clippy --fix

error[E0689]: can't call method `mul_add` on ambiguous numeric type `{float}`
 --> src/main.rs:3:15
  |
3 |     let y = x.mul_add(2.0, 1.0);
  |               ^^^^^^^
  |
help: you must specify a type for this binding, like `f32`
  |
2 |     let x: f32 = 1.0;
  |          +++++

error: aborting due to 1 previous error

[odysa]

This bug was reported before #10015

Related to clippy::suboptimal_flops
Related to this discussion
Maybe related to #11831