float_cmp: ignore when comparing with constant?

[birkenfeld]

Consider:

const ONE: f32 = 1.0;
fn main() {
    let v = 0.9;
    let _ = v == ONE;
}

These are probably cases where you want to check for the exact constant, because it is a common argument, a sentinel value, or an integer converted to floating-point due to external APIs, etc.

There is already a special case for 0 and +/-inf, but I'd add a case for this situation too.

[clippered]

Hi, was just about to look at this one. Is this still the case at the moment? Correct me if I'm mistaken but it looks like it is already been covered by the lint.

warning: strict comparison of f32 or f64
--> input.rs:9:13
|
9 | let _ = v == ONE;
| ^^^^^^^^ help: consider comparing them within some error: (v - ONE).abs() < error
|
= note: #[warn(float_cmp)] on by default
note: std::f32::EPSILON and std::f64::EPSILON are available.
--> input.rs:9:13
|
9 | let _ = v == ONE;
| ^^^^^^^^
= help: for further information visit https://rust-lang-nursery.github.io/rust-clippy/v0.0.165/index.html#float_cmp

[oli-obk]

This has not been covered yet. I think what @birkenfeld suggests is to not lint if at least one side of the == is just the name of a constant.

[clippered]

I see, thanks for the clarification @oli-obk . Do we also need to check if one side is an expression (e.g. (v+0.1) == ONE)? Or maybe it does not matter as long as one side is a constant.

[oli-obk]

As long as one side is a constant.

Instead of removing the linting if there are constants, we can add a restriction lint that still triggers. I'm fairly certain someone will want to forbid all float comparisons.