OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

casting integer literal to float is unnecessary

Browse Source
This commit is contained in:
rink1969 2019-03-12 15:49:26 +08:00
parent 8fc0a738e3
commit d9dd008e44
10 changed files with 237 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
clippy_lints/src/types.rs
View File

@ -10,7 +10,7 @@ use rustc::hir::intravisit::{walk_body, walk_expr, walk_ty, FnKind, NestedVisito
use rustc::hir::*;
use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass};
use rustc::ty::layout::LayoutOf;
use rustc::ty::{self, Ty, TyCtxt, TypeckTables};
use rustc::ty::{self, InferTy, Ty, TyCtxt, TypeckTables};
use rustc::{declare_tool_lint, lint_array};
use rustc_errors::Applicability;
use rustc_target::spec::abi::Abi;
@ -1150,6 +1150,16 @@ fn is_c_void(tcx: TyCtxt<'_, '_, '_>, ty: Ty<'_>) -> bool {
false
}
/// Returns the mantissa bits wide of a fp type.
/// Will return 0 if the type is not a fp
fn fp_ty_mantissa_nbits(typ: Ty<'_>) -> u32 {
match typ.sty {
ty::Float(FloatTy::F32) => 23,
ty::Float(FloatTy::F64) | ty::Infer(InferTy::FloatVar(_)) => 52,
_ => 0,
}
}
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CastPass {
fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
if let ExprKind::Cast(ref ex, _) = expr.node {
@ -1157,6 +1167,24 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CastPass {
lint_fn_to_numeric_cast(cx, expr, ex, cast_from, cast_to);
if let ExprKind::Lit(ref lit) = ex.node {
use syntax::ast::{LitIntType, LitKind};
if let LitKind::Int(n, _) = lit.node {
if cast_to.is_fp() {
let from_nbits = 128 - n.leading_zeros();
let to_nbits = fp_ty_mantissa_nbits(cast_to);
if from_nbits != 0 && to_nbits != 0 && from_nbits <= to_nbits {
span_lint_and_sugg(
cx,
UNNECESSARY_CAST,
expr.span,
&format!("casting integer literal to {} is unnecessary", cast_to),
"try",
format!("{}_{}", n, cast_to),
Applicability::MachineApplicable,
);
return;
}
}
}
match lit.node {
LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::FloatUnsuffixed(_) => {},
_ => {

20
tests/ui/cast.rs
View File

@ -8,12 +8,16 @@
#[allow(clippy::no_effect, clippy::unnecessary_operation)]
fn main() {
// Test clippy::cast_precision_loss
1i32 as f32;
1i64 as f32;
1i64 as f64;
1u32 as f32;
1u64 as f32;
1u64 as f64;
let x0 = 1i32;
x0 as f32;
let x1 = 1i64;
x1 as f32;
x1 as f64;
let x2 = 1u32;
x2 as f32;
let x3 = 1u64;
x3 as f32;
x3 as f64;
// Test clippy::cast_possible_truncation
1f32 as i32;
1f32 as u32;
@ -49,6 +53,10 @@ fn main() {
1f32 as f32;
false as bool;
&1i32 as &i32;
// casting integer literal to float is unnecessary
100 as f32;
100 as f64;
100_i32 as f64;
// Should not trigger
#[rustfmt::skip]
let v = vec!(1);

108
tests/ui/cast.stderr
View File

@ -1,43 +1,43 @@
error: casting i32 to f32 causes a loss of precision (i32 is 32 bits wide, but f32's mantissa is only 23 bits wide)
--> $DIR/cast.rs:11:5
--> $DIR/cast.rs:12:5
|
LL | 1i32 as f32;
| ^^^^^^^^^^^
LL | x0 as f32;
| ^^^^^^^^^
|
= note: `-D clippy::cast-precision-loss` implied by `-D warnings`
error: casting i64 to f32 causes a loss of precision (i64 is 64 bits wide, but f32's mantissa is only 23 bits wide)
--> $DIR/cast.rs:12:5
|
LL | 1i64 as f32;
| ^^^^^^^^^^^
error: casting i64 to f64 causes a loss of precision (i64 is 64 bits wide, but f64's mantissa is only 52 bits wide)
--> $DIR/cast.rs:13:5
|
LL | 1i64 as f64;
| ^^^^^^^^^^^
error: casting u32 to f32 causes a loss of precision (u32 is 32 bits wide, but f32's mantissa is only 23 bits wide)
--> $DIR/cast.rs:14:5
|
LL | 1u32 as f32;
| ^^^^^^^^^^^
LL | x1 as f32;
| ^^^^^^^^^
error: casting u64 to f32 causes a loss of precision (u64 is 64 bits wide, but f32's mantissa is only 23 bits wide)
error: casting i64 to f64 causes a loss of precision (i64 is 64 bits wide, but f64's mantissa is only 52 bits wide)
--> $DIR/cast.rs:15:5
|
LL | 1u64 as f32;
| ^^^^^^^^^^^
LL | x1 as f64;
| ^^^^^^^^^
error: casting u32 to f32 causes a loss of precision (u32 is 32 bits wide, but f32's mantissa is only 23 bits wide)
--> $DIR/cast.rs:17:5
|
LL | x2 as f32;
| ^^^^^^^^^
error: casting u64 to f32 causes a loss of precision (u64 is 64 bits wide, but f32's mantissa is only 23 bits wide)
--> $DIR/cast.rs:19:5
|
LL | x3 as f32;
| ^^^^^^^^^
error: casting u64 to f64 causes a loss of precision (u64 is 64 bits wide, but f64's mantissa is only 52 bits wide)
--> $DIR/cast.rs:16:5
--> $DIR/cast.rs:20:5
|
LL | 1u64 as f64;
| ^^^^^^^^^^^
LL | x3 as f64;
| ^^^^^^^^^
error: casting f32 to i32 may truncate the value
--> $DIR/cast.rs:18:5
--> $DIR/cast.rs:22:5
|
LL | 1f32 as i32;
| ^^^^^^^^^^^
@ -45,13 +45,13 @@ LL | 1f32 as i32;
= note: `-D clippy::cast-possible-truncation` implied by `-D warnings`
error: casting f32 to u32 may truncate the value
--> $DIR/cast.rs:19:5
--> $DIR/cast.rs:23:5
|
LL | 1f32 as u32;
| ^^^^^^^^^^^
error: casting f32 to u32 may lose the sign of the value
--> $DIR/cast.rs:19:5
--> $DIR/cast.rs:23:5
|
LL | 1f32 as u32;
| ^^^^^^^^^^^
@ -59,43 +59,43 @@ LL | 1f32 as u32;
= note: `-D clippy::cast-sign-loss` implied by `-D warnings`
error: casting f64 to f32 may truncate the value
--> $DIR/cast.rs:20:5
--> $DIR/cast.rs:24:5
|
LL | 1f64 as f32;
| ^^^^^^^^^^^
error: casting i32 to i8 may truncate the value
--> $DIR/cast.rs:21:5
--> $DIR/cast.rs:25:5
|
LL | 1i32 as i8;
| ^^^^^^^^^^
error: casting i32 to u8 may truncate the value
--> $DIR/cast.rs:22:5
--> $DIR/cast.rs:26:5
|
LL | 1i32 as u8;
| ^^^^^^^^^^
error: casting f64 to isize may truncate the value
--> $DIR/cast.rs:23:5
--> $DIR/cast.rs:27:5
|
LL | 1f64 as isize;
| ^^^^^^^^^^^^^
error: casting f64 to usize may truncate the value
--> $DIR/cast.rs:24:5
--> $DIR/cast.rs:28:5
|
LL | 1f64 as usize;
| ^^^^^^^^^^^^^
error: casting f64 to usize may lose the sign of the value
--> $DIR/cast.rs:24:5
--> $DIR/cast.rs:28:5
|
LL | 1f64 as usize;
| ^^^^^^^^^^^^^
error: casting u8 to i8 may wrap around the value
--> $DIR/cast.rs:26:5
--> $DIR/cast.rs:30:5
|
LL | 1u8 as i8;
| ^^^^^^^^^
@ -103,31 +103,31 @@ LL | 1u8 as i8;
= note: `-D clippy::cast-possible-wrap` implied by `-D warnings`
error: casting u16 to i16 may wrap around the value
--> $DIR/cast.rs:27:5
--> $DIR/cast.rs:31:5
|
LL | 1u16 as i16;
| ^^^^^^^^^^^
error: casting u32 to i32 may wrap around the value
--> $DIR/cast.rs:28:5
--> $DIR/cast.rs:32:5
|
LL | 1u32 as i32;
| ^^^^^^^^^^^
error: casting u64 to i64 may wrap around the value
--> $DIR/cast.rs:29:5
--> $DIR/cast.rs:33:5
|
LL | 1u64 as i64;
| ^^^^^^^^^^^
error: casting usize to isize may wrap around the value
--> $DIR/cast.rs:30:5
--> $DIR/cast.rs:34:5
|
LL | 1usize as isize;
| ^^^^^^^^^^^^^^^
error: casting f32 to f64 may become silently lossy if types change
--> $DIR/cast.rs:32:5
--> $DIR/cast.rs:36:5
|
LL | 1.0f32 as f64;
| ^^^^^^^^^^^^^ help: try: `f64::from(1.0f32)`
@ -135,25 +135,25 @@ LL | 1.0f32 as f64;
= note: `-D clippy::cast-lossless` implied by `-D warnings`
error: casting u8 to u16 may become silently lossy if types change
--> $DIR/cast.rs:34:5
--> $DIR/cast.rs:38:5
|
LL | (1u8 + 1u8) as u16;
| ^^^^^^^^^^^^^^^^^^ help: try: `u16::from(1u8 + 1u8)`
error: casting i32 to u32 may lose the sign of the value
--> $DIR/cast.rs:37:5
--> $DIR/cast.rs:41:5
|
LL | -1i32 as u32;
| ^^^^^^^^^^^^
error: casting isize to usize may lose the sign of the value
--> $DIR/cast.rs:39:5
--> $DIR/cast.rs:43:5
|
LL | -1isize as usize;
| ^^^^^^^^^^^^^^^^
error: casting to the same type is unnecessary (`i32` -> `i32`)
--> $DIR/cast.rs:48:5
--> $DIR/cast.rs:52:5
|
LL | 1i32 as i32;
| ^^^^^^^^^^^
@ -161,16 +161,34 @@ LL | 1i32 as i32;
= note: `-D clippy::unnecessary-cast` implied by `-D warnings`
error: casting to the same type is unnecessary (`f32` -> `f32`)
--> $DIR/cast.rs:49:5
--> $DIR/cast.rs:53:5
|
LL | 1f32 as f32;
| ^^^^^^^^^^^
error: casting to the same type is unnecessary (`bool` -> `bool`)
--> $DIR/cast.rs:50:5
--> $DIR/cast.rs:54:5
|
LL | false as bool;
| ^^^^^^^^^^^^^
error: aborting due to 27 previous errors
error: casting integer literal to f32 is unnecessary
--> $DIR/cast.rs:57:5
|
LL | 100 as f32;
| ^^^^^^^^^^ help: try: `100_f32`
error: casting integer literal to f64 is unnecessary
--> $DIR/cast.rs:58:5
|
LL | 100 as f64;
| ^^^^^^^^^^ help: try: `100_f64`
error: casting integer literal to f64 is unnecessary
--> $DIR/cast.rs:59:5
|
LL | 100_i32 as f64;
| ^^^^^^^^^^^^^^ help: try: `100_f64`
error: aborting due to 30 previous errors

26
tests/ui/cast_lossless_float.fixed
View File

@ -5,16 +5,22 @@
fn main() {
// Test clippy::cast_lossless with casts to floating-point types
f32::from(1i8);
f64::from(1i8);
f32::from(1u8);
f64::from(1u8);
f32::from(1i16);
f64::from(1i16);
f32::from(1u16);
f64::from(1u16);
f64::from(1i32);
f64::from(1u32);
let x0 = 1i8;
f32::from(x0);
f64::from(x0);
let x1 = 1u8;
f32::from(x1);
f64::from(x1);
let x2 = 1i16;
f32::from(x2);
f64::from(x2);
let x3 = 1u16;
f32::from(x3);
f64::from(x3);
let x4 = 1i32;
f64::from(x4);
let x5 = 1u32;
f64::from(x5);
}
// The lint would suggest using `f64::from(input)` here but the `XX::from` function is not const,

26
tests/ui/cast_lossless_float.rs
View File

@ -5,16 +5,22 @@
fn main() {
// Test clippy::cast_lossless with casts to floating-point types
1i8 as f32;
1i8 as f64;
1u8 as f32;
1u8 as f64;
1i16 as f32;
1i16 as f64;
1u16 as f32;
1u16 as f64;
1i32 as f64;
1u32 as f64;
let x0 = 1i8;
x0 as f32;
x0 as f64;
let x1 = 1u8;
x1 as f32;
x1 as f64;
let x2 = 1i16;
x2 as f32;
x2 as f64;
let x3 = 1u16;
x3 as f32;
x3 as f64;
let x4 = 1i32;
x4 as f64;
let x5 = 1u32;
x5 as f64;
}
// The lint would suggest using `f64::from(input)` here but the `XX::from` function is not const,

76
tests/ui/cast_lossless_float.stderr
View File

@ -1,64 +1,64 @@
error: casting i8 to f32 may become silently lossy if types change
--> $DIR/cast_lossless_float.rs:8:5
--> $DIR/cast_lossless_float.rs:9:5
|
LL | 1i8 as f32;
| ^^^^^^^^^^ help: try: `f32::from(1i8)`
LL | x0 as f32;
| ^^^^^^^^^ help: try: `f32::from(x0)`
|
= note: `-D clippy::cast-lossless` implied by `-D warnings`
error: casting i8 to f64 may become silently lossy if types change
--> $DIR/cast_lossless_float.rs:9:5
|
LL | 1i8 as f64;
| ^^^^^^^^^^ help: try: `f64::from(1i8)`
error: casting u8 to f32 may become silently lossy if types change
--> $DIR/cast_lossless_float.rs:10:5
|
LL | 1u8 as f32;
| ^^^^^^^^^^ help: try: `f32::from(1u8)`
LL | x0 as f64;
| ^^^^^^^^^ help: try: `f64::from(x0)`
error: casting u8 to f64 may become silently lossy if types change
--> $DIR/cast_lossless_float.rs:11:5
|
LL | 1u8 as f64;
| ^^^^^^^^^^ help: try: `f64::from(1u8)`
error: casting i16 to f32 may become silently lossy if types change
error: casting u8 to f32 may become silently lossy if types change
--> $DIR/cast_lossless_float.rs:12:5
|
LL | 1i16 as f32;
| ^^^^^^^^^^^ help: try: `f32::from(1i16)`
LL | x1 as f32;
| ^^^^^^^^^ help: try: `f32::from(x1)`
error: casting i16 to f64 may become silently lossy if types change
error: casting u8 to f64 may become silently lossy if types change
--> $DIR/cast_lossless_float.rs:13:5
|
LL | 1i16 as f64;
| ^^^^^^^^^^^ help: try: `f64::from(1i16)`
LL | x1 as f64;
| ^^^^^^^^^ help: try: `f64::from(x1)`
error: casting u16 to f32 may become silently lossy if types change
--> $DIR/cast_lossless_float.rs:14:5
|
LL | 1u16 as f32;
| ^^^^^^^^^^^ help: try: `f32::from(1u16)`
error: casting u16 to f64 may become silently lossy if types change
error: casting i16 to f32 may become silently lossy if types change
--> $DIR/cast_lossless_float.rs:15:5
|
LL | 1u16 as f64;
| ^^^^^^^^^^^ help: try: `f64::from(1u16)`
LL | x2 as f32;
| ^^^^^^^^^ help: try: `f32::from(x2)`
error: casting i32 to f64 may become silently lossy if types change
error: casting i16 to f64 may become silently lossy if types change
--> $DIR/cast_lossless_float.rs:16:5
|
LL | 1i32 as f64;
| ^^^^^^^^^^^ help: try: `f64::from(1i32)`
LL | x2 as f64;
| ^^^^^^^^^ help: try: `f64::from(x2)`
error: casting u16 to f32 may become silently lossy if types change
--> $DIR/cast_lossless_float.rs:18:5
|
LL | x3 as f32;
| ^^^^^^^^^ help: try: `f32::from(x3)`
error: casting u16 to f64 may become silently lossy if types change
--> $DIR/cast_lossless_float.rs:19:5
|
LL | x3 as f64;
| ^^^^^^^^^ help: try: `f64::from(x3)`
error: casting i32 to f64 may become silently lossy if types change
--> $DIR/cast_lossless_float.rs:21:5
|
LL | x4 as f64;
| ^^^^^^^^^ help: try: `f64::from(x4)`
error: casting u32 to f64 may become silently lossy if types change
--> $DIR/cast_lossless_float.rs:17:5
--> $DIR/cast_lossless_float.rs:23:5
|
LL | 1u32 as f64;
| ^^^^^^^^^^^ help: try: `f64::from(1u32)`
LL | x5 as f64;
| ^^^^^^^^^ help: try: `f64::from(x5)`
error: aborting due to 10 previous errors

13
tests/ui/cast_size.rs
View File

@ -9,10 +9,12 @@
fn main() {
// Casting from *size
1isize as i8;
1isize as f64;
1usize as f64;
1isize as f32;
1usize as f32;
let x0 = 1isize;
let x1 = 1usize;
x0 as f64;
x1 as f64;
x0 as f32;
x1 as f32;
1isize as i32;
1isize as u32;
1usize as u32;
@ -26,4 +28,7 @@ fn main() {
1u32 as usize; // Should not trigger any lint
1i32 as isize; // Neither should this
1i32 as usize;
// Big integer literal to float
999_999_999 as f32;
9_999_999_999_999_999usize as f64;
}

70
tests/ui/cast_size.stderr
View File

@ -7,57 +7,57 @@ LL | 1isize as i8;
= note: `-D clippy::cast-possible-truncation` implied by `-D warnings`
error: casting isize to f64 causes a loss of precision on targets with 64-bit wide pointers (isize is 64 bits wide, but f64's mantissa is only 52 bits wide)
--> $DIR/cast_size.rs:12:5
--> $DIR/cast_size.rs:14:5
|
LL | 1isize as f64;
| ^^^^^^^^^^^^^
LL | x0 as f64;
| ^^^^^^^^^
|
= note: `-D clippy::cast-precision-loss` implied by `-D warnings`
error: casting usize to f64 causes a loss of precision on targets with 64-bit wide pointers (usize is 64 bits wide, but f64's mantissa is only 52 bits wide)
--> $DIR/cast_size.rs:13:5
|
LL | 1usize as f64;
| ^^^^^^^^^^^^^
error: casting isize to f32 causes a loss of precision (isize is 32 or 64 bits wide, but f32's mantissa is only 23 bits wide)
--> $DIR/cast_size.rs:14:5
|
LL | 1isize as f32;
| ^^^^^^^^^^^^^
error: casting usize to f32 causes a loss of precision (usize is 32 or 64 bits wide, but f32's mantissa is only 23 bits wide)
--> $DIR/cast_size.rs:15:5
|
LL | 1usize as f32;
| ^^^^^^^^^^^^^
LL | x1 as f64;
| ^^^^^^^^^
error: casting isize to f32 causes a loss of precision (isize is 32 or 64 bits wide, but f32's mantissa is only 23 bits wide)
--> $DIR/cast_size.rs:16:5
|
LL | x0 as f32;
| ^^^^^^^^^
error: casting usize to f32 causes a loss of precision (usize is 32 or 64 bits wide, but f32's mantissa is only 23 bits wide)
--> $DIR/cast_size.rs:17:5
|
LL | x1 as f32;
| ^^^^^^^^^
error: casting isize to i32 may truncate the value on targets with 64-bit wide pointers
--> $DIR/cast_size.rs:16:5
--> $DIR/cast_size.rs:18:5
|
LL | 1isize as i32;
| ^^^^^^^^^^^^^
error: casting isize to u32 may truncate the value on targets with 64-bit wide pointers
--> $DIR/cast_size.rs:17:5
--> $DIR/cast_size.rs:19:5
|
LL | 1isize as u32;
| ^^^^^^^^^^^^^
error: casting usize to u32 may truncate the value on targets with 64-bit wide pointers
--> $DIR/cast_size.rs:18:5
--> $DIR/cast_size.rs:20:5
|
LL | 1usize as u32;
| ^^^^^^^^^^^^^
error: casting usize to i32 may truncate the value on targets with 64-bit wide pointers
--> $DIR/cast_size.rs:19:5
--> $DIR/cast_size.rs:21:5
|
LL | 1usize as i32;
| ^^^^^^^^^^^^^
error: casting usize to i32 may wrap around the value on targets with 32-bit wide pointers
--> $DIR/cast_size.rs:19:5
--> $DIR/cast_size.rs:21:5
|
LL | 1usize as i32;
| ^^^^^^^^^^^^^
@ -65,40 +65,52 @@ LL | 1usize as i32;
= note: `-D clippy::cast-possible-wrap` implied by `-D warnings`
error: casting i64 to isize may truncate the value on targets with 32-bit wide pointers
--> $DIR/cast_size.rs:21:5
--> $DIR/cast_size.rs:23:5
|
LL | 1i64 as isize;
| ^^^^^^^^^^^^^
error: casting i64 to usize may truncate the value on targets with 32-bit wide pointers
--> $DIR/cast_size.rs:22:5
--> $DIR/cast_size.rs:24:5
|
LL | 1i64 as usize;
| ^^^^^^^^^^^^^
error: casting u64 to isize may truncate the value on targets with 32-bit wide pointers
--> $DIR/cast_size.rs:23:5
--> $DIR/cast_size.rs:25:5
|
LL | 1u64 as isize;
| ^^^^^^^^^^^^^
error: casting u64 to isize may wrap around the value on targets with 64-bit wide pointers
--> $DIR/cast_size.rs:23:5
--> $DIR/cast_size.rs:25:5
|
LL | 1u64 as isize;
| ^^^^^^^^^^^^^
error: casting u64 to usize may truncate the value on targets with 32-bit wide pointers
--> $DIR/cast_size.rs:24:5
--> $DIR/cast_size.rs:26:5
|
LL | 1u64 as usize;
| ^^^^^^^^^^^^^
error: casting u32 to isize may wrap around the value on targets with 32-bit wide pointers
--> $DIR/cast_size.rs:25:5
--> $DIR/cast_size.rs:27:5
|
LL | 1u32 as isize;
| ^^^^^^^^^^^^^
error: aborting due to 16 previous errors
error: casting i32 to f32 causes a loss of precision (i32 is 32 bits wide, but f32's mantissa is only 23 bits wide)
--> $DIR/cast_size.rs:32:5
|
LL | 999_999_999 as f32;
| ^^^^^^^^^^^^^^^^^^
error: casting usize to f64 causes a loss of precision on targets with 64-bit wide pointers (usize is 64 bits wide, but f64's mantissa is only 52 bits wide)
--> $DIR/cast_size.rs:33:5
|
LL | 9_999_999_999_999_999usize as f64;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to 18 previous errors

3
tests/ui/float_cmp_const.rs
View File

@ -19,7 +19,8 @@ fn main() {
TWO == ONE;
TWO != ONE;
ONE + ONE == TWO;
1 as f32 == ONE;
let x = 1;
x as f32 == ONE;
let v = 0.9;
v == ONE;

18
tests/ui/float_cmp_const.stderr
View File

@ -48,37 +48,37 @@ LL | ONE + ONE == TWO;
| ^^^^^^^^^^^^^^^^
error: strict comparison of f32 or f64 constant
--> $DIR/float_cmp_const.rs:22:5
--> $DIR/float_cmp_const.rs:23:5
|
LL | 1 as f32 == ONE;
| ^^^^^^^^^^^^^^^ help: consider comparing them within some error: `(1 as f32 - ONE).abs() < error`
LL | x as f32 == ONE;
| ^^^^^^^^^^^^^^^ help: consider comparing them within some error: `(x as f32 - ONE).abs() < error`
|
note: std::f32::EPSILON and std::f64::EPSILON are available.
--> $DIR/float_cmp_const.rs:22:5
--> $DIR/float_cmp_const.rs:23:5
|
LL | 1 as f32 == ONE;
LL | x as f32 == ONE;
| ^^^^^^^^^^^^^^^
error: strict comparison of f32 or f64 constant
--> $DIR/float_cmp_const.rs:25:5
--> $DIR/float_cmp_const.rs:26:5
|
LL | v == ONE;
| ^^^^^^^^ help: consider comparing them within some error: `(v - ONE).abs() < error`
|
note: std::f32::EPSILON and std::f64::EPSILON are available.
--> $DIR/float_cmp_const.rs:25:5
--> $DIR/float_cmp_const.rs:26:5
|
LL | v == ONE;
| ^^^^^^^^
error: strict comparison of f32 or f64 constant
--> $DIR/float_cmp_const.rs:26:5
--> $DIR/float_cmp_const.rs:27:5
|
LL | v != ONE;
| ^^^^^^^^ help: consider comparing them within some error: `(v - ONE).abs() < error`
|
note: std::f32::EPSILON and std::f64::EPSILON are available.
--> $DIR/float_cmp_const.rs:26:5
--> $DIR/float_cmp_const.rs:27:5
|
LL | v != ONE;
| ^^^^^^^^