Mirrors/rust-clippy
2
0
Fork 0
mirror of https://github.com/rust-lang/rust-clippy synced 2024-11-27 23:20:39 +00:00
Code Issues Projects Releases Packages Wiki Activity

Auto merge of #9576 - TennyZhuang:unnecessary_cast_for_non_literal_expr, r=llogiq

Browse source 
let unnecessary_cast work for trivial non_literal expressions

Signed-off-by: TennyZhuang <zty0826@gmail.com>

---

changelog: [`unnecessary_cast`]: fix for trivial non_literal expressions

Fixes #9562
This commit is contained in:
bors 2022-10-02 15:26:45 +00:00
commit f8ba19287d
24 changed files with 141 additions and 100 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

43
clippy_lints/src/casts/unnecessary_cast.rs
View file

@ -31,8 +31,10 @@ pub(super) fn check<'tcx>(
} }
} }
let cast_str = snippet_opt(cx, cast_expr.span).unwrap_or_default();
if let Some(lit) = get_numeric_literal(cast_expr) { if let Some(lit) = get_numeric_literal(cast_expr) {
let literal_str = snippet_opt(cx, cast_expr.span).unwrap_or_default(); let literal_str = &cast_str;
if_chain! { if_chain! {
if let LitKind::Int(n, _) = lit.node; if let LitKind::Int(n, _) = lit.node;
@ -50,12 +52,16 @@ pub(super) fn check<'tcx>(
match lit.node { match lit.node {
LitKind::Int(_, LitIntType::Unsuffixed) if cast_to.is_integral() => { LitKind::Int(_, LitIntType::Unsuffixed) if cast_to.is_integral() => {
lint_unnecessary_cast(cx, expr, &literal_str, cast_from, cast_to); lint_unnecessary_cast(cx, expr, literal_str, cast_from, cast_to);
return false;
}, },
LitKind::Float(_, LitFloatType::Unsuffixed) if cast_to.is_floating_point() => { LitKind::Float(_, LitFloatType::Unsuffixed) if cast_to.is_floating_point() => {
lint_unnecessary_cast(cx, expr, &literal_str, cast_from, cast_to); lint_unnecessary_cast(cx, expr, literal_str, cast_from, cast_to);
return false;
},
LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed) => {
return false;
}, },
LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed) => {},
LitKind::Int(_, LitIntType::Signed(_) | LitIntType::Unsigned(_)) LitKind::Int(_, LitIntType::Signed(_) | LitIntType::Unsigned(_))
| LitKind::Float(_, LitFloatType::Suffixed(_)) | LitKind::Float(_, LitFloatType::Suffixed(_))
if cast_from.kind() == cast_to.kind() => if cast_from.kind() == cast_to.kind() =>
@ -63,26 +69,27 @@ pub(super) fn check<'tcx>(
if let Some(src) = snippet_opt(cx, cast_expr.span) { if let Some(src) = snippet_opt(cx, cast_expr.span) {
if let Some(num_lit) = NumericLiteral::from_lit_kind(&src, &lit.node) { if let Some(num_lit) = NumericLiteral::from_lit_kind(&src, &lit.node) {
lint_unnecessary_cast(cx, expr, num_lit.integer, cast_from, cast_to); lint_unnecessary_cast(cx, expr, num_lit.integer, cast_from, cast_to);
return true;
} }
} }
}, },
_ => { _ => {},
if cast_from.kind() == cast_to.kind() && !in_external_macro(cx.sess(), expr.span) {
span_lint_and_sugg(
cx,
UNNECESSARY_CAST,
expr.span,
&format!("casting to the same type is unnecessary (`{cast_from}` -> `{cast_to}`)"),
"try",
literal_str,
Applicability::MachineApplicable,
);
return true;
}
},
} }
} }
if cast_from.kind() == cast_to.kind() && !in_external_macro(cx.sess(), expr.span) {
span_lint_and_sugg(
cx,
UNNECESSARY_CAST,
expr.span,
&format!("casting to the same type is unnecessary (`{cast_from}` -> `{cast_to}`)"),
"try",
cast_str,
Applicability::MachineApplicable,
);
return true;
}
false false
} }

1
tests/ui/floating_point_exp.fixed
View file

@ -1,5 +1,6 @@
// run-rustfix // run-rustfix
#![warn(clippy::imprecise_flops)] #![warn(clippy::imprecise_flops)]
#![allow(clippy::unnecessary_cast)]
fn main() { fn main() {
let x = 2f32; let x = 2f32;

1
tests/ui/floating_point_exp.rs
View file

@ -1,5 +1,6 @@
// run-rustfix // run-rustfix
#![warn(clippy::imprecise_flops)] #![warn(clippy::imprecise_flops)]
#![allow(clippy::unnecessary_cast)]
fn main() { fn main() {
let x = 2f32; let x = 2f32;

10
tests/ui/floating_point_exp.stderr
View file

@ -1,5 +1,5 @@
error: (e.pow(x) - 1) can be computed more accurately error: (e.pow(x) - 1) can be computed more accurately
--> $DIR/floating_point_exp.rs:6:13 --> $DIR/floating_point_exp.rs:7:13
| |
LL | let _ = x.exp() - 1.0; LL | let _ = x.exp() - 1.0;
| ^^^^^^^^^^^^^ help: consider using: `x.exp_m1()` | ^^^^^^^^^^^^^ help: consider using: `x.exp_m1()`
@ -7,25 +7,25 @@ LL | let _ = x.exp() - 1.0;
= note: `-D clippy::imprecise-flops` implied by `-D warnings` = note: `-D clippy::imprecise-flops` implied by `-D warnings`
error: (e.pow(x) - 1) can be computed more accurately error: (e.pow(x) - 1) can be computed more accurately
--> $DIR/floating_point_exp.rs:7:13 --> $DIR/floating_point_exp.rs:8:13
| |
LL | let _ = x.exp() - 1.0 + 2.0; LL | let _ = x.exp() - 1.0 + 2.0;
| ^^^^^^^^^^^^^ help: consider using: `x.exp_m1()` | ^^^^^^^^^^^^^ help: consider using: `x.exp_m1()`
error: (e.pow(x) - 1) can be computed more accurately error: (e.pow(x) - 1) can be computed more accurately
--> $DIR/floating_point_exp.rs:8:13 --> $DIR/floating_point_exp.rs:9:13
| |
LL | let _ = (x as f32).exp() - 1.0 + 2.0; LL | let _ = (x as f32).exp() - 1.0 + 2.0;
| ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x as f32).exp_m1()` | ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x as f32).exp_m1()`
error: (e.pow(x) - 1) can be computed more accurately error: (e.pow(x) - 1) can be computed more accurately
--> $DIR/floating_point_exp.rs:14:13 --> $DIR/floating_point_exp.rs:15:13
| |
LL | let _ = x.exp() - 1.0; LL | let _ = x.exp() - 1.0;
| ^^^^^^^^^^^^^ help: consider using: `x.exp_m1()` | ^^^^^^^^^^^^^ help: consider using: `x.exp_m1()`
error: (e.pow(x) - 1) can be computed more accurately error: (e.pow(x) - 1) can be computed more accurately
--> $DIR/floating_point_exp.rs:15:13 --> $DIR/floating_point_exp.rs:16:13
| |
LL | let _ = x.exp() - 1.0 + 2.0; LL | let _ = x.exp() - 1.0 + 2.0;
| ^^^^^^^^^^^^^ help: consider using: `x.exp_m1()` | ^^^^^^^^^^^^^ help: consider using: `x.exp_m1()`

2
tests/ui/floating_point_log.fixed
View file

@ -1,5 +1,5 @@
// run-rustfix // run-rustfix
#![allow(dead_code, clippy::double_parens)] #![allow(dead_code, clippy::double_parens, clippy::unnecessary_cast)]
#![warn(clippy::suboptimal_flops, clippy::imprecise_flops)] #![warn(clippy::suboptimal_flops, clippy::imprecise_flops)]
const TWO: f32 = 2.0; const TWO: f32 = 2.0;

2
tests/ui/floating_point_log.rs
View file

@ -1,5 +1,5 @@
// run-rustfix // run-rustfix
#![allow(dead_code, clippy::double_parens)] #![allow(dead_code, clippy::double_parens, clippy::unnecessary_cast)]
#![warn(clippy::suboptimal_flops, clippy::imprecise_flops)] #![warn(clippy::suboptimal_flops, clippy::imprecise_flops)]
const TWO: f32 = 2.0; const TWO: f32 = 2.0;

1
tests/ui/floating_point_logbase.fixed
View file

@ -1,5 +1,6 @@
// run-rustfix // run-rustfix
#![warn(clippy::suboptimal_flops)] #![warn(clippy::suboptimal_flops)]
#![allow(clippy::unnecessary_cast)]
fn main() { fn main() {
let x = 3f32; let x = 3f32;

1
tests/ui/floating_point_logbase.rs
View file

@ -1,5 +1,6 @@
// run-rustfix // run-rustfix
#![warn(clippy::suboptimal_flops)] #![warn(clippy::suboptimal_flops)]
#![allow(clippy::unnecessary_cast)]
fn main() { fn main() {
let x = 3f32; let x = 3f32;

10
tests/ui/floating_point_logbase.stderr
View file

@ -1,5 +1,5 @@
error: log base can be expressed more clearly error: log base can be expressed more clearly
--> $DIR/floating_point_logbase.rs:7:13 --> $DIR/floating_point_logbase.rs:8:13
| |
LL | let _ = x.ln() / y.ln(); LL | let _ = x.ln() / y.ln();
| ^^^^^^^^^^^^^^^ help: consider using: `x.log(y)` | ^^^^^^^^^^^^^^^ help: consider using: `x.log(y)`
@ -7,25 +7,25 @@ LL | let _ = x.ln() / y.ln();
= note: `-D clippy::suboptimal-flops` implied by `-D warnings` = note: `-D clippy::suboptimal-flops` implied by `-D warnings`
error: log base can be expressed more clearly error: log base can be expressed more clearly
--> $DIR/floating_point_logbase.rs:8:13 --> $DIR/floating_point_logbase.rs:9:13
| |
LL | let _ = (x as f32).ln() / y.ln(); LL | let _ = (x as f32).ln() / y.ln();
| ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x as f32).log(y)` | ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x as f32).log(y)`
error: log base can be expressed more clearly error: log base can be expressed more clearly
--> $DIR/floating_point_logbase.rs:9:13 --> $DIR/floating_point_logbase.rs:10:13
| |
LL | let _ = x.log2() / y.log2(); LL | let _ = x.log2() / y.log2();
| ^^^^^^^^^^^^^^^^^^^ help: consider using: `x.log(y)` | ^^^^^^^^^^^^^^^^^^^ help: consider using: `x.log(y)`
error: log base can be expressed more clearly error: log base can be expressed more clearly
--> $DIR/floating_point_logbase.rs:10:13 --> $DIR/floating_point_logbase.rs:11:13
| |
LL | let _ = x.log10() / y.log10(); LL | let _ = x.log10() / y.log10();
| ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.log(y)` | ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.log(y)`
error: log base can be expressed more clearly error: log base can be expressed more clearly
--> $DIR/floating_point_logbase.rs:11:13 --> $DIR/floating_point_logbase.rs:12:13
| |
LL | let _ = x.log(5f32) / y.log(5f32); LL | let _ = x.log(5f32) / y.log(5f32);
| ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.log(y)` | ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.log(y)`

1
tests/ui/floating_point_powf.fixed
View file

@ -1,5 +1,6 @@
// run-rustfix // run-rustfix
#![warn(clippy::suboptimal_flops, clippy::imprecise_flops)] #![warn(clippy::suboptimal_flops, clippy::imprecise_flops)]
#![allow(clippy::unnecessary_cast)]
fn main() { fn main() {
let x = 3f32; let x = 3f32;

1
tests/ui/floating_point_powf.rs
View file

@ -1,5 +1,6 @@
// run-rustfix // run-rustfix
#![warn(clippy::suboptimal_flops, clippy::imprecise_flops)] #![warn(clippy::suboptimal_flops, clippy::imprecise_flops)]
#![allow(clippy::unnecessary_cast)]
fn main() { fn main() {
let x = 3f32; let x = 3f32;

62
tests/ui/floating_point_powf.stderr
View file

@ -1,5 +1,5 @@
error: exponent for bases 2 and e can be computed more accurately error: exponent for bases 2 and e can be computed more accurately
--> $DIR/floating_point_powf.rs:6:13 --> $DIR/floating_point_powf.rs:7:13
| |
LL | let _ = 2f32.powf(x); LL | let _ = 2f32.powf(x);
| ^^^^^^^^^^^^ help: consider using: `x.exp2()` | ^^^^^^^^^^^^ help: consider using: `x.exp2()`
@ -7,43 +7,43 @@ LL | let _ = 2f32.powf(x);
= note: `-D clippy::suboptimal-flops` implied by `-D warnings` = note: `-D clippy::suboptimal-flops` implied by `-D warnings`
error: exponent for bases 2 and e can be computed more accurately error: exponent for bases 2 and e can be computed more accurately
--> $DIR/floating_point_powf.rs:7:13 --> $DIR/floating_point_powf.rs:8:13
| |
LL | let _ = 2f32.powf(3.1); LL | let _ = 2f32.powf(3.1);
| ^^^^^^^^^^^^^^ help: consider using: `3.1f32.exp2()` | ^^^^^^^^^^^^^^ help: consider using: `3.1f32.exp2()`
error: exponent for bases 2 and e can be computed more accurately error: exponent for bases 2 and e can be computed more accurately
--> $DIR/floating_point_powf.rs:8:13 --> $DIR/floating_point_powf.rs:9:13
| |
LL | let _ = 2f32.powf(-3.1); LL | let _ = 2f32.powf(-3.1);
| ^^^^^^^^^^^^^^^ help: consider using: `(-3.1f32).exp2()` | ^^^^^^^^^^^^^^^ help: consider using: `(-3.1f32).exp2()`
error: exponent for bases 2 and e can be computed more accurately error: exponent for bases 2 and e can be computed more accurately
--> $DIR/floating_point_powf.rs:9:13 --> $DIR/floating_point_powf.rs:10:13
| |
LL | let _ = std::f32::consts::E.powf(x); LL | let _ = std::f32::consts::E.powf(x);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.exp()` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.exp()`
error: exponent for bases 2 and e can be computed more accurately error: exponent for bases 2 and e can be computed more accurately
--> $DIR/floating_point_powf.rs:10:13 --> $DIR/floating_point_powf.rs:11:13
| |
LL | let _ = std::f32::consts::E.powf(3.1); LL | let _ = std::f32::consts::E.powf(3.1);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `3.1f32.exp()` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `3.1f32.exp()`
error: exponent for bases 2 and e can be computed more accurately error: exponent for bases 2 and e can be computed more accurately
--> $DIR/floating_point_powf.rs:11:13 --> $DIR/floating_point_powf.rs:12:13
| |
LL | let _ = std::f32::consts::E.powf(-3.1); LL | let _ = std::f32::consts::E.powf(-3.1);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(-3.1f32).exp()` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(-3.1f32).exp()`
error: square-root of a number can be computed more efficiently and accurately error: square-root of a number can be computed more efficiently and accurately
--> $DIR/floating_point_powf.rs:12:13 --> $DIR/floating_point_powf.rs:13:13
| |
LL | let _ = x.powf(1.0 / 2.0); LL | let _ = x.powf(1.0 / 2.0);
| ^^^^^^^^^^^^^^^^^ help: consider using: `x.sqrt()` | ^^^^^^^^^^^^^^^^^ help: consider using: `x.sqrt()`
error: cube-root of a number can be computed more accurately error: cube-root of a number can be computed more accurately
--> $DIR/floating_point_powf.rs:13:13 --> $DIR/floating_point_powf.rs:14:13
| |
LL | let _ = x.powf(1.0 / 3.0); LL | let _ = x.powf(1.0 / 3.0);
| ^^^^^^^^^^^^^^^^^ help: consider using: `x.cbrt()` | ^^^^^^^^^^^^^^^^^ help: consider using: `x.cbrt()`
@ -51,139 +51,139 @@ LL | let _ = x.powf(1.0 / 3.0);
= note: `-D clippy::imprecise-flops` implied by `-D warnings` = note: `-D clippy::imprecise-flops` implied by `-D warnings`
error: cube-root of a number can be computed more accurately error: cube-root of a number can be computed more accurately
--> $DIR/floating_point_powf.rs:14:13 --> $DIR/floating_point_powf.rs:15:13
| |
LL | let _ = (x as f32).powf(1.0 / 3.0); LL | let _ = (x as f32).powf(1.0 / 3.0);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x as f32).cbrt()` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x as f32).cbrt()`
error: exponentiation with integer powers can be computed more efficiently error: exponentiation with integer powers can be computed more efficiently
--> $DIR/floating_point_powf.rs:15:13 --> $DIR/floating_point_powf.rs:16:13
| |
LL | let _ = x.powf(3.0); LL | let _ = x.powf(3.0);
| ^^^^^^^^^^^ help: consider using: `x.powi(3)` | ^^^^^^^^^^^ help: consider using: `x.powi(3)`
error: exponentiation with integer powers can be computed more efficiently error: exponentiation with integer powers can be computed more efficiently
--> $DIR/floating_point_powf.rs:16:13 --> $DIR/floating_point_powf.rs:17:13
| |
LL | let _ = x.powf(-2.0); LL | let _ = x.powf(-2.0);
| ^^^^^^^^^^^^ help: consider using: `x.powi(-2)` | ^^^^^^^^^^^^ help: consider using: `x.powi(-2)`
error: exponentiation with integer powers can be computed more efficiently error: exponentiation with integer powers can be computed more efficiently
--> $DIR/floating_point_powf.rs:17:13 --> $DIR/floating_point_powf.rs:18:13
| |
LL | let _ = x.powf(16_777_215.0); LL | let _ = x.powf(16_777_215.0);
| ^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(16_777_215)` | ^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(16_777_215)`
error: exponentiation with integer powers can be computed more efficiently error: exponentiation with integer powers can be computed more efficiently
--> $DIR/floating_point_powf.rs:18:13 --> $DIR/floating_point_powf.rs:19:13
| |
LL | let _ = x.powf(-16_777_215.0); LL | let _ = x.powf(-16_777_215.0);
| ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(-16_777_215)` | ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(-16_777_215)`
error: exponentiation with integer powers can be computed more efficiently error: exponentiation with integer powers can be computed more efficiently
--> $DIR/floating_point_powf.rs:19:13 --> $DIR/floating_point_powf.rs:20:13
| |
LL | let _ = (x as f32).powf(-16_777_215.0); LL | let _ = (x as f32).powf(-16_777_215.0);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x as f32).powi(-16_777_215)` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x as f32).powi(-16_777_215)`
error: exponentiation with integer powers can be computed more efficiently error: exponentiation with integer powers can be computed more efficiently
--> $DIR/floating_point_powf.rs:20:13 --> $DIR/floating_point_powf.rs:21:13
| |
LL | let _ = (x as f32).powf(3.0); LL | let _ = (x as f32).powf(3.0);
| ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x as f32).powi(3)` | ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x as f32).powi(3)`
error: cube-root of a number can be computed more accurately error: cube-root of a number can be computed more accurately
--> $DIR/floating_point_powf.rs:21:13 --> $DIR/floating_point_powf.rs:22:13
| |
LL | let _ = (1.5_f32 + 1.0).powf(1.0 / 3.0); LL | let _ = (1.5_f32 + 1.0).powf(1.0 / 3.0);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(1.5_f32 + 1.0).cbrt()` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(1.5_f32 + 1.0).cbrt()`
error: cube-root of a number can be computed more accurately error: cube-root of a number can be computed more accurately
--> $DIR/floating_point_powf.rs:22:13 --> $DIR/floating_point_powf.rs:23:13
| |
LL | let _ = 1.5_f64.powf(1.0 / 3.0); LL | let _ = 1.5_f64.powf(1.0 / 3.0);
| ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `1.5_f64.cbrt()` | ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `1.5_f64.cbrt()`
error: square-root of a number can be computed more efficiently and accurately error: square-root of a number can be computed more efficiently and accurately
--> $DIR/floating_point_powf.rs:23:13 --> $DIR/floating_point_powf.rs:24:13
| |
LL | let _ = 1.5_f64.powf(1.0 / 2.0); LL | let _ = 1.5_f64.powf(1.0 / 2.0);
| ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `1.5_f64.sqrt()` | ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `1.5_f64.sqrt()`
error: exponentiation with integer powers can be computed more efficiently error: exponentiation with integer powers can be computed more efficiently
--> $DIR/floating_point_powf.rs:24:13 --> $DIR/floating_point_powf.rs:25:13
| |
LL | let _ = 1.5_f64.powf(3.0); LL | let _ = 1.5_f64.powf(3.0);
| ^^^^^^^^^^^^^^^^^ help: consider using: `1.5_f64.powi(3)` | ^^^^^^^^^^^^^^^^^ help: consider using: `1.5_f64.powi(3)`
error: exponent for bases 2 and e can be computed more accurately error: exponent for bases 2 and e can be computed more accurately
--> $DIR/floating_point_powf.rs:33:13 --> $DIR/floating_point_powf.rs:34:13
| |
LL | let _ = 2f64.powf(x); LL | let _ = 2f64.powf(x);
| ^^^^^^^^^^^^ help: consider using: `x.exp2()` | ^^^^^^^^^^^^ help: consider using: `x.exp2()`
error: exponent for bases 2 and e can be computed more accurately error: exponent for bases 2 and e can be computed more accurately
--> $DIR/floating_point_powf.rs:34:13 --> $DIR/floating_point_powf.rs:35:13
| |
LL | let _ = 2f64.powf(3.1); LL | let _ = 2f64.powf(3.1);
| ^^^^^^^^^^^^^^ help: consider using: `3.1f64.exp2()` | ^^^^^^^^^^^^^^ help: consider using: `3.1f64.exp2()`
error: exponent for bases 2 and e can be computed more accurately error: exponent for bases 2 and e can be computed more accurately
--> $DIR/floating_point_powf.rs:35:13 --> $DIR/floating_point_powf.rs:36:13
| |
LL | let _ = 2f64.powf(-3.1); LL | let _ = 2f64.powf(-3.1);
| ^^^^^^^^^^^^^^^ help: consider using: `(-3.1f64).exp2()` | ^^^^^^^^^^^^^^^ help: consider using: `(-3.1f64).exp2()`
error: exponent for bases 2 and e can be computed more accurately error: exponent for bases 2 and e can be computed more accurately
--> $DIR/floating_point_powf.rs:36:13 --> $DIR/floating_point_powf.rs:37:13
| |
LL | let _ = std::f64::consts::E.powf(x); LL | let _ = std::f64::consts::E.powf(x);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.exp()` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.exp()`
error: exponent for bases 2 and e can be computed more accurately error: exponent for bases 2 and e can be computed more accurately
--> $DIR/floating_point_powf.rs:37:13 --> $DIR/floating_point_powf.rs:38:13
| |
LL | let _ = std::f64::consts::E.powf(3.1); LL | let _ = std::f64::consts::E.powf(3.1);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `3.1f64.exp()` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `3.1f64.exp()`
error: exponent for bases 2 and e can be computed more accurately error: exponent for bases 2 and e can be computed more accurately
--> $DIR/floating_point_powf.rs:38:13 --> $DIR/floating_point_powf.rs:39:13
| |
LL | let _ = std::f64::consts::E.powf(-3.1); LL | let _ = std::f64::consts::E.powf(-3.1);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(-3.1f64).exp()` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(-3.1f64).exp()`
error: square-root of a number can be computed more efficiently and accurately error: square-root of a number can be computed more efficiently and accurately
--> $DIR/floating_point_powf.rs:39:13 --> $DIR/floating_point_powf.rs:40:13
| |
LL | let _ = x.powf(1.0 / 2.0); LL | let _ = x.powf(1.0 / 2.0);
| ^^^^^^^^^^^^^^^^^ help: consider using: `x.sqrt()` | ^^^^^^^^^^^^^^^^^ help: consider using: `x.sqrt()`
error: cube-root of a number can be computed more accurately error: cube-root of a number can be computed more accurately
--> $DIR/floating_point_powf.rs:40:13 --> $DIR/floating_point_powf.rs:41:13
| |
LL | let _ = x.powf(1.0 / 3.0); LL | let _ = x.powf(1.0 / 3.0);
| ^^^^^^^^^^^^^^^^^ help: consider using: `x.cbrt()` | ^^^^^^^^^^^^^^^^^ help: consider using: `x.cbrt()`
error: exponentiation with integer powers can be computed more efficiently error: exponentiation with integer powers can be computed more efficiently
--> $DIR/floating_point_powf.rs:41:13 --> $DIR/floating_point_powf.rs:42:13
| |
LL | let _ = x.powf(3.0); LL | let _ = x.powf(3.0);
| ^^^^^^^^^^^ help: consider using: `x.powi(3)` | ^^^^^^^^^^^ help: consider using: `x.powi(3)`
error: exponentiation with integer powers can be computed more efficiently error: exponentiation with integer powers can be computed more efficiently
--> $DIR/floating_point_powf.rs:42:13 --> $DIR/floating_point_powf.rs:43:13
| |
LL | let _ = x.powf(-2.0); LL | let _ = x.powf(-2.0);
| ^^^^^^^^^^^^ help: consider using: `x.powi(-2)` | ^^^^^^^^^^^^ help: consider using: `x.powi(-2)`
error: exponentiation with integer powers can be computed more efficiently error: exponentiation with integer powers can be computed more efficiently
--> $DIR/floating_point_powf.rs:43:13 --> $DIR/floating_point_powf.rs:44:13
| |
LL | let _ = x.powf(-2_147_483_648.0); LL | let _ = x.powf(-2_147_483_648.0);
| ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(-2_147_483_648)` | ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(-2_147_483_648)`
error: exponentiation with integer powers can be computed more efficiently error: exponentiation with integer powers can be computed more efficiently
--> $DIR/floating_point_powf.rs:44:13 --> $DIR/floating_point_powf.rs:45:13
| |
LL | let _ = x.powf(2_147_483_647.0); LL | let _ = x.powf(2_147_483_647.0);
| ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(2_147_483_647)` | ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(2_147_483_647)`

1
tests/ui/floating_point_powi.fixed
View file

@ -1,5 +1,6 @@
// run-rustfix // run-rustfix
#![warn(clippy::suboptimal_flops)] #![warn(clippy::suboptimal_flops)]
#![allow(clippy::unnecessary_cast)]
fn main() { fn main() {
let one = 1; let one = 1;

1
tests/ui/floating_point_powi.rs
View file

@ -1,5 +1,6 @@
// run-rustfix // run-rustfix
#![warn(clippy::suboptimal_flops)] #![warn(clippy::suboptimal_flops)]
#![allow(clippy::unnecessary_cast)]
fn main() { fn main() {
let one = 1; let one = 1;

10
tests/ui/floating_point_powi.stderr
View file

@ -1,5 +1,5 @@
error: multiply and add expressions can be calculated more efficiently and accurately error: multiply and add expressions can be calculated more efficiently and accurately
--> $DIR/floating_point_powi.rs:9:13 --> $DIR/floating_point_powi.rs:10:13
| |
LL | let _ = x.powi(2) + y; LL | let _ = x.powi(2) + y;
| ^^^^^^^^^^^^^ help: consider using: `x.mul_add(x, y)` | ^^^^^^^^^^^^^ help: consider using: `x.mul_add(x, y)`
@ -7,25 +7,25 @@ LL | let _ = x.powi(2) + y;
= note: `-D clippy::suboptimal-flops` implied by `-D warnings` = note: `-D clippy::suboptimal-flops` implied by `-D warnings`
error: multiply and add expressions can be calculated more efficiently and accurately error: multiply and add expressions can be calculated more efficiently and accurately
--> $DIR/floating_point_powi.rs:10:13 --> $DIR/floating_point_powi.rs:11:13
| |
LL | let _ = x + y.powi(2); LL | let _ = x + y.powi(2);
| ^^^^^^^^^^^^^ help: consider using: `y.mul_add(y, x)` | ^^^^^^^^^^^^^ help: consider using: `y.mul_add(y, x)`
error: multiply and add expressions can be calculated more efficiently and accurately error: multiply and add expressions can be calculated more efficiently and accurately
--> $DIR/floating_point_powi.rs:11:13 --> $DIR/floating_point_powi.rs:12:13
| |
LL | let _ = x + (y as f32).powi(2); LL | let _ = x + (y as f32).powi(2);
| ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(y as f32).mul_add(y as f32, x)` | ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(y as f32).mul_add(y as f32, x)`
error: multiply and add expressions can be calculated more efficiently and accurately error: multiply and add expressions can be calculated more efficiently and accurately
--> $DIR/floating_point_powi.rs:12:13 --> $DIR/floating_point_powi.rs:13:13
| |
LL | let _ = (x.powi(2) + y).sqrt(); LL | let _ = (x.powi(2) + y).sqrt();
| ^^^^^^^^^^^^^^^ help: consider using: `x.mul_add(x, y)` | ^^^^^^^^^^^^^^^ help: consider using: `x.mul_add(x, y)`
error: multiply and add expressions can be calculated more efficiently and accurately error: multiply and add expressions can be calculated more efficiently and accurately
--> $DIR/floating_point_powi.rs:13:13 --> $DIR/floating_point_powi.rs:14:13
| |
LL | let _ = (x + y.powi(2)).sqrt(); LL | let _ = (x + y.powi(2)).sqrt();
| ^^^^^^^^^^^^^^^ help: consider using: `y.mul_add(y, x)` | ^^^^^^^^^^^^^^^ help: consider using: `y.mul_add(y, x)`

3
tests/ui/manual_bits.fixed
View file

@ -6,7 +6,8 @@
clippy::useless_conversion, clippy::useless_conversion,
path_statements, path_statements,
unused_must_use, unused_must_use,
clippy::unnecessary_operation clippy::unnecessary_operation,
clippy::unnecessary_cast
)] )]
use std::mem::{size_of, size_of_val}; use std::mem::{size_of, size_of_val};

3
tests/ui/manual_bits.rs
View file

@ -6,7 +6,8 @@
clippy::useless_conversion, clippy::useless_conversion,
path_statements, path_statements,
unused_must_use, unused_must_use,
clippy::unnecessary_operation clippy::unnecessary_operation,
clippy::unnecessary_cast
)] )]
use std::mem::{size_of, size_of_val}; use std::mem::{size_of, size_of_val};

58
tests/ui/manual_bits.stderr
View file

@ -1,5 +1,5 @@
error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
--> $DIR/manual_bits.rs:15:5 --> $DIR/manual_bits.rs:16:5
| |
LL | size_of::<i8>() * 8; LL | size_of::<i8>() * 8;
| ^^^^^^^^^^^^^^^^^^^ help: consider using: `i8::BITS as usize` | ^^^^^^^^^^^^^^^^^^^ help: consider using: `i8::BITS as usize`
@ -7,169 +7,169 @@ LL | size_of::<i8>() * 8;
= note: `-D clippy::manual-bits` implied by `-D warnings` = note: `-D clippy::manual-bits` implied by `-D warnings`
error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
--> $DIR/manual_bits.rs:16:5 --> $DIR/manual_bits.rs:17:5
| |
LL | size_of::<i16>() * 8; LL | size_of::<i16>() * 8;
| ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i16::BITS as usize` | ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i16::BITS as usize`
error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
--> $DIR/manual_bits.rs:17:5 --> $DIR/manual_bits.rs:18:5
| |
LL | size_of::<i32>() * 8; LL | size_of::<i32>() * 8;
| ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i32::BITS as usize` | ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i32::BITS as usize`
error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
--> $DIR/manual_bits.rs:18:5 --> $DIR/manual_bits.rs:19:5
| |
LL | size_of::<i64>() * 8; LL | size_of::<i64>() * 8;
| ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i64::BITS as usize` | ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i64::BITS as usize`
error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
--> $DIR/manual_bits.rs:19:5 --> $DIR/manual_bits.rs:20:5
| |
LL | size_of::<i128>() * 8; LL | size_of::<i128>() * 8;
| ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `i128::BITS as usize` | ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `i128::BITS as usize`
error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
--> $DIR/manual_bits.rs:20:5 --> $DIR/manual_bits.rs:21:5
| |
LL | size_of::<isize>() * 8; LL | size_of::<isize>() * 8;
| ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `isize::BITS as usize` | ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `isize::BITS as usize`
error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
--> $DIR/manual_bits.rs:22:5 --> $DIR/manual_bits.rs:23:5
| |
LL | size_of::<u8>() * 8; LL | size_of::<u8>() * 8;
| ^^^^^^^^^^^^^^^^^^^ help: consider using: `u8::BITS as usize` | ^^^^^^^^^^^^^^^^^^^ help: consider using: `u8::BITS as usize`
error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
--> $DIR/manual_bits.rs:23:5 --> $DIR/manual_bits.rs:24:5
| |
LL | size_of::<u16>() * 8; LL | size_of::<u16>() * 8;
| ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u16::BITS as usize` | ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u16::BITS as usize`
error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
--> $DIR/manual_bits.rs:24:5 --> $DIR/manual_bits.rs:25:5
| |
LL | size_of::<u32>() * 8; LL | size_of::<u32>() * 8;
| ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u32::BITS as usize` | ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u32::BITS as usize`
error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
--> $DIR/manual_bits.rs:25:5 --> $DIR/manual_bits.rs:26:5
| |
LL | size_of::<u64>() * 8; LL | size_of::<u64>() * 8;
| ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u64::BITS as usize` | ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u64::BITS as usize`
error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
--> $DIR/manual_bits.rs:26:5 --> $DIR/manual_bits.rs:27:5
| |
LL | size_of::<u128>() * 8; LL | size_of::<u128>() * 8;
| ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `u128::BITS as usize` | ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `u128::BITS as usize`
error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
--> $DIR/manual_bits.rs:27:5 --> $DIR/manual_bits.rs:28:5
| |
LL | size_of::<usize>() * 8; LL | size_of::<usize>() * 8;
| ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `usize::BITS as usize` | ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `usize::BITS as usize`
error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
--> $DIR/manual_bits.rs:29:5 --> $DIR/manual_bits.rs:30:5
| |
LL | 8 * size_of::<i8>(); LL | 8 * size_of::<i8>();
| ^^^^^^^^^^^^^^^^^^^ help: consider using: `i8::BITS as usize` | ^^^^^^^^^^^^^^^^^^^ help: consider using: `i8::BITS as usize`
error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
--> $DIR/manual_bits.rs:30:5 --> $DIR/manual_bits.rs:31:5
| |
LL | 8 * size_of::<i16>(); LL | 8 * size_of::<i16>();
| ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i16::BITS as usize` | ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i16::BITS as usize`
error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
--> $DIR/manual_bits.rs:31:5 --> $DIR/manual_bits.rs:32:5
| |
LL | 8 * size_of::<i32>(); LL | 8 * size_of::<i32>();
| ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i32::BITS as usize` | ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i32::BITS as usize`
error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
--> $DIR/manual_bits.rs:32:5 --> $DIR/manual_bits.rs:33:5
| |
LL | 8 * size_of::<i64>(); LL | 8 * size_of::<i64>();
| ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i64::BITS as usize` | ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i64::BITS as usize`
error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
--> $DIR/manual_bits.rs:33:5 --> $DIR/manual_bits.rs:34:5
| |
LL | 8 * size_of::<i128>(); LL | 8 * size_of::<i128>();
| ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `i128::BITS as usize` | ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `i128::BITS as usize`
error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
--> $DIR/manual_bits.rs:34:5 --> $DIR/manual_bits.rs:35:5
| |
LL | 8 * size_of::<isize>(); LL | 8 * size_of::<isize>();
| ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `isize::BITS as usize` | ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `isize::BITS as usize`
error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
--> $DIR/manual_bits.rs:36:5 --> $DIR/manual_bits.rs:37:5
| |
LL | 8 * size_of::<u8>(); LL | 8 * size_of::<u8>();
| ^^^^^^^^^^^^^^^^^^^ help: consider using: `u8::BITS as usize` | ^^^^^^^^^^^^^^^^^^^ help: consider using: `u8::BITS as usize`
error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
--> $DIR/manual_bits.rs:37:5 --> $DIR/manual_bits.rs:38:5
| |
LL | 8 * size_of::<u16>(); LL | 8 * size_of::<u16>();
| ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u16::BITS as usize` | ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u16::BITS as usize`
error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
--> $DIR/manual_bits.rs:38:5 --> $DIR/manual_bits.rs:39:5
| |
LL | 8 * size_of::<u32>(); LL | 8 * size_of::<u32>();
| ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u32::BITS as usize` | ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u32::BITS as usize`
error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
--> $DIR/manual_bits.rs:39:5 --> $DIR/manual_bits.rs:40:5
| |
LL | 8 * size_of::<u64>(); LL | 8 * size_of::<u64>();
| ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u64::BITS as usize` | ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u64::BITS as usize`
error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
--> $DIR/manual_bits.rs:40:5 --> $DIR/manual_bits.rs:41:5
| |
LL | 8 * size_of::<u128>(); LL | 8 * size_of::<u128>();
| ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `u128::BITS as usize` | ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `u128::BITS as usize`
error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
--> $DIR/manual_bits.rs:41:5 --> $DIR/manual_bits.rs:42:5
| |
LL | 8 * size_of::<usize>(); LL | 8 * size_of::<usize>();
| ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `usize::BITS as usize` | ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `usize::BITS as usize`
error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
--> $DIR/manual_bits.rs:51:5 --> $DIR/manual_bits.rs:52:5
| |
LL | size_of::<Word>() * 8; LL | size_of::<Word>() * 8;
| ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `Word::BITS as usize` | ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `Word::BITS as usize`
error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
--> $DIR/manual_bits.rs:55:18 --> $DIR/manual_bits.rs:56:18
| |
LL | let _: u32 = (size_of::<u128>() * 8) as u32; LL | let _: u32 = (size_of::<u128>() * 8) as u32;
| ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `u128::BITS` | ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `u128::BITS`
error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
--> $DIR/manual_bits.rs:56:18 --> $DIR/manual_bits.rs:57:18
| |
LL | let _: u32 = (size_of::<u128>() * 8).try_into().unwrap(); LL | let _: u32 = (size_of::<u128>() * 8).try_into().unwrap();
| ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `u128::BITS` | ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `u128::BITS`
error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
--> $DIR/manual_bits.rs:57:13 --> $DIR/manual_bits.rs:58:13
| |
LL | let _ = (size_of::<u128>() * 8).pow(5); LL | let _ = (size_of::<u128>() * 8).pow(5);
| ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(u128::BITS as usize)` | ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(u128::BITS as usize)`
error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
--> $DIR/manual_bits.rs:58:14 --> $DIR/manual_bits.rs:59:14
| |
LL | let _ = &(size_of::<u128>() * 8); LL | let _ = &(size_of::<u128>() * 8);
| ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(u128::BITS as usize)` | ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(u128::BITS as usize)`

1
tests/ui/ptr_offset_with_cast.fixed
View file

@ -1,4 +1,5 @@
// run-rustfix // run-rustfix
#![allow(clippy::unnecessary_cast)]
fn main() { fn main() {
let vec = vec![b'a', b'b', b'c']; let vec = vec![b'a', b'b', b'c'];

1
tests/ui/ptr_offset_with_cast.rs
View file

@ -1,4 +1,5 @@
// run-rustfix // run-rustfix
#![allow(clippy::unnecessary_cast)]
fn main() { fn main() {
let vec = vec![b'a', b'b', b'c']; let vec = vec![b'a', b'b', b'c'];

4
tests/ui/ptr_offset_with_cast.stderr
View file

@ -1,5 +1,5 @@
error: use of `offset` with a `usize` casted to an `isize` error: use of `offset` with a `usize` casted to an `isize`
--> $DIR/ptr_offset_with_cast.rs:12:17 --> $DIR/ptr_offset_with_cast.rs:13:17
| |
LL | let _ = ptr.offset(offset_usize as isize); LL | let _ = ptr.offset(offset_usize as isize);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `ptr.add(offset_usize)` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `ptr.add(offset_usize)`
@ -7,7 +7,7 @@ LL | let _ = ptr.offset(offset_usize as isize);
= note: `-D clippy::ptr-offset-with-cast` implied by `-D warnings` = note: `-D clippy::ptr-offset-with-cast` implied by `-D warnings`
error: use of `wrapping_offset` with a `usize` casted to an `isize` error: use of `wrapping_offset` with a `usize` casted to an `isize`
--> $DIR/ptr_offset_with_cast.rs:16:17 --> $DIR/ptr_offset_with_cast.rs:17:17
| |
LL | let _ = ptr.wrapping_offset(offset_usize as isize); LL | let _ = ptr.wrapping_offset(offset_usize as isize);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `ptr.wrapping_add(offset_usize)` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `ptr.wrapping_add(offset_usize)`

8
tests/ui/unnecessary_cast.fixed
View file

@ -103,4 +103,12 @@ mod fixable {
#[allow(clippy::precedence)] #[allow(clippy::precedence)]
let _: f64 = -8.0_f64.exp(); // should suggest `-8.0_f64.exp()` here not to change code behavior let _: f64 = -8.0_f64.exp(); // should suggest `-8.0_f64.exp()` here not to change code behavior
} }
fn issue_9562_non_literal() {
fn foo() -> f32 {
0.
}
let _num = foo();
}
} }

8
tests/ui/unnecessary_cast.rs
View file

@ -103,4 +103,12 @@ mod fixable {
#[allow(clippy::precedence)] #[allow(clippy::precedence)]
let _: f64 = -(8.0 as f64).exp(); // should suggest `-8.0_f64.exp()` here not to change code behavior let _: f64 = -(8.0 as f64).exp(); // should suggest `-8.0_f64.exp()` here not to change code behavior
} }
fn issue_9562_non_literal() {
fn foo() -> f32 {
0.
}
let _num = foo() as f32;
}
} }

8
tests/ui/unnecessary_cast.stderr
View file

@ -174,5 +174,11 @@ error: casting float literal to `f64` is unnecessary
LL | let _: f64 = -(8.0 as f64).exp(); // should suggest `-8.0_f64.exp()` here not to change code behavior LL | let _: f64 = -(8.0 as f64).exp(); // should suggest `-8.0_f64.exp()` here not to change code behavior
| ^^^^^^^^^^^^ help: try: `8.0_f64` | ^^^^^^^^^^^^ help: try: `8.0_f64`
error: aborting due to 29 previous errors error: casting to the same type is unnecessary (`f32` -> `f32`)
--> $DIR/unnecessary_cast.rs:112:20
|
LL | let _num = foo() as f32;
| ^^^^^^^^^^^^ help: try: `foo()`
error: aborting due to 30 previous errors