about summary refs log tree commit diff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--tests/ui/floating_point_exp.rs17
-rw-r--r--tests/ui/floating_point_exp.stderr28
-rw-r--r--tests/ui/floating_point_log.rs (renamed from tests/ui/floating_point_arithmetic.rs)42
-rw-r--r--tests/ui/floating_point_log.stderr (renamed from tests/ui/floating_point_arithmetic.stderr)154
-rw-r--r--tests/ui/floating_point_powf.rs27
-rw-r--r--tests/ui/floating_point_powf.stderr76
6 files changed, 177 insertions, 167 deletions
diff --git a/tests/ui/floating_point_exp.rs b/tests/ui/floating_point_exp.rs
new file mode 100644
index 00000000000..303c6124775
--- /dev/null
+++ b/tests/ui/floating_point_exp.rs
@@ -0,0 +1,17 @@
+#![warn(clippy::floating_point_improvements)]
+
+fn main() {
+    let x = 2f32;
+    let _ = x.exp() - 1.0;
+    let _ = x.exp() - 1.0 + 2.0;
+    // Cases where the lint shouldn't be applied
+    let _ = x.exp() - 2.0;
+    let _ = x.exp() - 1.0 * 2.0;
+
+    let x = 2f64;
+    let _ = x.exp() - 1.0;
+    let _ = x.exp() - 1.0 + 2.0;
+    // Cases where the lint shouldn't be applied
+    let _ = x.exp() - 2.0;
+    let _ = x.exp() - 1.0 * 2.0;
+}
diff --git a/tests/ui/floating_point_exp.stderr b/tests/ui/floating_point_exp.stderr
new file mode 100644
index 00000000000..78321899945
--- /dev/null
+++ b/tests/ui/floating_point_exp.stderr
@@ -0,0 +1,28 @@
+error: (e.pow(x) - 1) can be computed more accurately
+  --> $DIR/floating_point_exp.rs:5:13
+   |
+LL |     let _ = x.exp() - 1.0;
+   |             ^^^^^^^^^^^^^ help: consider using: `x.exp_m1()`
+   |
+   = note: `-D clippy::floating-point-improvements` implied by `-D warnings`
+
+error: (e.pow(x) - 1) can be computed more accurately
+  --> $DIR/floating_point_exp.rs:6:13
+   |
+LL |     let _ = x.exp() - 1.0 + 2.0;
+   |             ^^^^^^^^^^^^^ help: consider using: `x.exp_m1()`
+
+error: (e.pow(x) - 1) can be computed more accurately
+  --> $DIR/floating_point_exp.rs:12:13
+   |
+LL |     let _ = x.exp() - 1.0;
+   |             ^^^^^^^^^^^^^ help: consider using: `x.exp_m1()`
+
+error: (e.pow(x) - 1) can be computed more accurately
+  --> $DIR/floating_point_exp.rs:13:13
+   |
+LL |     let _ = x.exp() - 1.0 + 2.0;
+   |             ^^^^^^^^^^^^^ help: consider using: `x.exp_m1()`
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/floating_point_arithmetic.rs b/tests/ui/floating_point_log.rs
index ff594941546..4c01d5e716b 100644
--- a/tests/ui/floating_point_arithmetic.rs
+++ b/tests/ui/floating_point_log.rs
@@ -40,48 +40,6 @@ fn check_ln1p() {
     let _ = (1.0 + x - 2.0).ln();
 }
 
-fn check_powf() {
-    let x = 3f32;
-    let _ = 2f32.powf(x);
-    let _ = std::f32::consts::E.powf(x);
-    let _ = x.powf(1.0 / 2.0);
-    let _ = x.powf(1.0 / 3.0);
-    let _ = x.powf(2.0);
-    let _ = x.powf(-2.0);
-    let _ = x.powf(2.1);
-    let _ = x.powf(-2.1);
-    let _ = x.powf(16_777_217.0);
-    let _ = x.powf(-16_777_217.0);
-
-    let x = 3f64;
-    let _ = 2f64.powf(x);
-    let _ = std::f64::consts::E.powf(x);
-    let _ = x.powf(1.0 / 2.0);
-    let _ = x.powf(1.0 / 3.0);
-    let _ = x.powf(2.0);
-    let _ = x.powf(-2.0);
-    let _ = x.powf(2.1);
-    let _ = x.powf(-2.1);
-    let _ = x.powf(9_007_199_254_740_993.0);
-    let _ = x.powf(-9_007_199_254_740_993.0);
-}
-
-fn check_expm1() {
-    let x = 2f32;
-    let _ = x.exp() - 1.0;
-    let _ = x.exp() - 1.0 + 2.0;
-    // Cases where the lint shouldn't be applied
-    let _ = x.exp() - 2.0;
-    let _ = x.exp() - 1.0 * 2.0;
-
-    let x = 2f64;
-    let _ = x.exp() - 1.0;
-    let _ = x.exp() - 1.0 + 2.0;
-    // Cases where the lint shouldn't be applied
-    let _ = x.exp() - 2.0;
-    let _ = x.exp() - 1.0 * 2.0;
-}
-
 fn check_log_division() {
     let x = 3f32;
     let y = 2f32;
diff --git a/tests/ui/floating_point_arithmetic.stderr b/tests/ui/floating_point_log.stderr
index 076b8d4fefe..0a36f8fc69f 100644
--- a/tests/ui/floating_point_arithmetic.stderr
+++ b/tests/ui/floating_point_log.stderr
@@ -1,5 +1,5 @@
 error: logarithm for bases 2, 10 and e can be computed more accurately
-  --> $DIR/floating_point_arithmetic.rs:9:13
+  --> $DIR/floating_point_log.rs:9:13
    |
 LL |     let _ = x.log(2f32);
    |             ^^^^^^^^^^^ help: consider using: `x.log2()`
@@ -7,262 +7,166 @@ LL |     let _ = x.log(2f32);
    = note: `-D clippy::floating-point-improvements` implied by `-D warnings`
 
 error: logarithm for bases 2, 10 and e can be computed more accurately
-  --> $DIR/floating_point_arithmetic.rs:10:13
+  --> $DIR/floating_point_log.rs:10:13
    |
 LL |     let _ = x.log(10f32);
    |             ^^^^^^^^^^^^ help: consider using: `x.log10()`
 
 error: logarithm for bases 2, 10 and e can be computed more accurately
-  --> $DIR/floating_point_arithmetic.rs:11:13
+  --> $DIR/floating_point_log.rs:11:13
    |
 LL |     let _ = x.log(std::f32::consts::E);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.ln()`
 
 error: logarithm for bases 2, 10 and e can be computed more accurately
-  --> $DIR/floating_point_arithmetic.rs:12:13
+  --> $DIR/floating_point_log.rs:12:13
    |
 LL |     let _ = x.log(TWO);
    |             ^^^^^^^^^^ help: consider using: `x.log2()`
 
 error: logarithm for bases 2, 10 and e can be computed more accurately
-  --> $DIR/floating_point_arithmetic.rs:13:13
+  --> $DIR/floating_point_log.rs:13:13
    |
 LL |     let _ = x.log(E);
    |             ^^^^^^^^ help: consider using: `x.ln()`
 
 error: logarithm for bases 2, 10 and e can be computed more accurately
-  --> $DIR/floating_point_arithmetic.rs:16:13
+  --> $DIR/floating_point_log.rs:16:13
    |
 LL |     let _ = x.log(2f64);
    |             ^^^^^^^^^^^ help: consider using: `x.log2()`
 
 error: logarithm for bases 2, 10 and e can be computed more accurately
-  --> $DIR/floating_point_arithmetic.rs:17:13
+  --> $DIR/floating_point_log.rs:17:13
    |
 LL |     let _ = x.log(10f64);
    |             ^^^^^^^^^^^^ help: consider using: `x.log10()`
 
 error: logarithm for bases 2, 10 and e can be computed more accurately
-  --> $DIR/floating_point_arithmetic.rs:18:13
+  --> $DIR/floating_point_log.rs:18:13
    |
 LL |     let _ = x.log(std::f64::consts::E);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.ln()`
 
 error: ln(1 + x) can be computed more accurately
-  --> $DIR/floating_point_arithmetic.rs:23:13
+  --> $DIR/floating_point_log.rs:23:13
    |
 LL |     let _ = (1.0 + x).ln();
    |             ^^^^^^^^^^^^^^ help: consider using: `x.ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> $DIR/floating_point_arithmetic.rs:24:13
+  --> $DIR/floating_point_log.rs:24:13
    |
 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_arithmetic.rs:25:13
+  --> $DIR/floating_point_log.rs:25:13
    |
 LL |     let _ = (1.0 + x.powi(2)).ln();
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(2).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> $DIR/floating_point_arithmetic.rs:26:13
+  --> $DIR/floating_point_log.rs:26:13
    |
 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_arithmetic.rs:27:13
+  --> $DIR/floating_point_log.rs:27:13
    |
 LL |     let _ = (1.0 + (std::f32::consts::E - 1.0)).ln();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `((std::f32::consts::E - 1.0)).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> $DIR/floating_point_arithmetic.rs:34:13
+  --> $DIR/floating_point_log.rs:34:13
    |
 LL |     let _ = (1.0 + x).ln();
    |             ^^^^^^^^^^^^^^ help: consider using: `x.ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> $DIR/floating_point_arithmetic.rs:35:13
+  --> $DIR/floating_point_log.rs:35:13
    |
 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_arithmetic.rs:36:13
+  --> $DIR/floating_point_log.rs:36:13
    |
 LL |     let _ = (1.0 + x.powi(2)).ln();
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(2).ln_1p()`
 
-error: exponent for bases 2 and e can be computed more accurately
-  --> $DIR/floating_point_arithmetic.rs:45:13
-   |
-LL |     let _ = 2f32.powf(x);
-   |             ^^^^^^^^^^^^ help: consider using: `x.exp2()`
-
-error: exponent for bases 2 and e can be computed more accurately
-  --> $DIR/floating_point_arithmetic.rs:46:13
-   |
-LL |     let _ = std::f32::consts::E.powf(x);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.exp()`
-
-error: square-root of a number can be computed more efficiently and accurately
-  --> $DIR/floating_point_arithmetic.rs:47:13
-   |
-LL |     let _ = x.powf(1.0 / 2.0);
-   |             ^^^^^^^^^^^^^^^^^ help: consider using: `x.sqrt()`
-
-error: cube-root of a number can be computed more accurately
-  --> $DIR/floating_point_arithmetic.rs:48:13
-   |
-LL |     let _ = x.powf(1.0 / 3.0);
-   |             ^^^^^^^^^^^^^^^^^ help: consider using: `x.cbrt()`
-
-error: exponentiation with integer powers can be computed more efficiently
-  --> $DIR/floating_point_arithmetic.rs:49:13
-   |
-LL |     let _ = x.powf(2.0);
-   |             ^^^^^^^^^^^ help: consider using: `x.powi(2)`
-
-error: exponentiation with integer powers can be computed more efficiently
-  --> $DIR/floating_point_arithmetic.rs:50:13
-   |
-LL |     let _ = x.powf(-2.0);
-   |             ^^^^^^^^^^^^ help: consider using: `x.powi(-2)`
-
-error: exponent for bases 2 and e can be computed more accurately
-  --> $DIR/floating_point_arithmetic.rs:57:13
-   |
-LL |     let _ = 2f64.powf(x);
-   |             ^^^^^^^^^^^^ help: consider using: `x.exp2()`
-
-error: exponent for bases 2 and e can be computed more accurately
-  --> $DIR/floating_point_arithmetic.rs:58:13
-   |
-LL |     let _ = std::f64::consts::E.powf(x);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.exp()`
-
-error: square-root of a number can be computed more efficiently and accurately
-  --> $DIR/floating_point_arithmetic.rs:59:13
-   |
-LL |     let _ = x.powf(1.0 / 2.0);
-   |             ^^^^^^^^^^^^^^^^^ help: consider using: `x.sqrt()`
-
-error: cube-root of a number can be computed more accurately
-  --> $DIR/floating_point_arithmetic.rs:60:13
-   |
-LL |     let _ = x.powf(1.0 / 3.0);
-   |             ^^^^^^^^^^^^^^^^^ help: consider using: `x.cbrt()`
-
-error: exponentiation with integer powers can be computed more efficiently
-  --> $DIR/floating_point_arithmetic.rs:61:13
-   |
-LL |     let _ = x.powf(2.0);
-   |             ^^^^^^^^^^^ help: consider using: `x.powi(2)`
-
-error: exponentiation with integer powers can be computed more efficiently
-  --> $DIR/floating_point_arithmetic.rs:62:13
-   |
-LL |     let _ = x.powf(-2.0);
-   |             ^^^^^^^^^^^^ help: consider using: `x.powi(-2)`
-
-error: (e.pow(x) - 1) can be computed more accurately
-  --> $DIR/floating_point_arithmetic.rs:71:13
-   |
-LL |     let _ = x.exp() - 1.0;
-   |             ^^^^^^^^^^^^^ help: consider using: `x.exp_m1()`
-
-error: (e.pow(x) - 1) can be computed more accurately
-  --> $DIR/floating_point_arithmetic.rs:72:13
-   |
-LL |     let _ = x.exp() - 1.0 + 2.0;
-   |             ^^^^^^^^^^^^^ help: consider using: `x.exp_m1()`
-
-error: (e.pow(x) - 1) can be computed more accurately
-  --> $DIR/floating_point_arithmetic.rs:78:13
-   |
-LL |     let _ = x.exp() - 1.0;
-   |             ^^^^^^^^^^^^^ help: consider using: `x.exp_m1()`
-
-error: (e.pow(x) - 1) can be computed more accurately
-  --> $DIR/floating_point_arithmetic.rs:79:13
-   |
-LL |     let _ = x.exp() - 1.0 + 2.0;
-   |             ^^^^^^^^^^^^^ help: consider using: `x.exp_m1()`
-
 error: x.log(b) / y.log(b) can be reduced to x.log(y)
-  --> $DIR/floating_point_arithmetic.rs:90:13
+  --> $DIR/floating_point_log.rs:48:13
    |
 LL |     let _ = x.log2() / y.log2();
    |             ^^^^^^^^^^^^^^^^^^^ help: consider using: `x.log(y)`
 
 error: x.log(b) / y.log(b) can be reduced to x.log(y)
-  --> $DIR/floating_point_arithmetic.rs:91:13
+  --> $DIR/floating_point_log.rs:49:13
    |
 LL |     let _ = x.log10() / y.log10();
    |             ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.log(y)`
 
 error: x.log(b) / y.log(b) can be reduced to x.log(y)
-  --> $DIR/floating_point_arithmetic.rs:92:13
+  --> $DIR/floating_point_log.rs:50:13
    |
 LL |     let _ = x.ln() / y.ln();
    |             ^^^^^^^^^^^^^^^ help: consider using: `x.log(y)`
 
 error: x.log(b) / y.log(b) can be reduced to x.log(y)
-  --> $DIR/floating_point_arithmetic.rs:93:13
+  --> $DIR/floating_point_log.rs:51:13
    |
 LL |     let _ = x.log(4.0) / y.log(4.0);
    |             ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.log(y)`
 
 error: x.log(b) / y.log(b) can be reduced to x.log(y)
-  --> $DIR/floating_point_arithmetic.rs:94:13
+  --> $DIR/floating_point_log.rs:52:13
    |
 LL |     let _ = x.log(b) / y.log(b);
    |             ^^^^^^^^^^^^^^^^^^^ help: consider using: `x.log(y)`
 
 error: x.log(b) / y.log(b) can be reduced to x.log(y)
-  --> $DIR/floating_point_arithmetic.rs:96:13
+  --> $DIR/floating_point_log.rs:54:13
    |
 LL |     let _ = x.log(b) / 2f32.log(b);
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.log2()`
 
 error: x.log(b) / y.log(b) can be reduced to x.log(y)
-  --> $DIR/floating_point_arithmetic.rs:102:13
+  --> $DIR/floating_point_log.rs:60:13
    |
 LL |     let _ = x.log2() / y.log2();
    |             ^^^^^^^^^^^^^^^^^^^ help: consider using: `x.log(y)`
 
 error: x.log(b) / y.log(b) can be reduced to x.log(y)
-  --> $DIR/floating_point_arithmetic.rs:103:13
+  --> $DIR/floating_point_log.rs:61:13
    |
 LL |     let _ = x.log10() / y.log10();
    |             ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.log(y)`
 
 error: x.log(b) / y.log(b) can be reduced to x.log(y)
-  --> $DIR/floating_point_arithmetic.rs:104:13
+  --> $DIR/floating_point_log.rs:62:13
    |
 LL |     let _ = x.ln() / y.ln();
    |             ^^^^^^^^^^^^^^^ help: consider using: `x.log(y)`
 
 error: x.log(b) / y.log(b) can be reduced to x.log(y)
-  --> $DIR/floating_point_arithmetic.rs:105:13
+  --> $DIR/floating_point_log.rs:63:13
    |
 LL |     let _ = x.log(4.0) / y.log(4.0);
    |             ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.log(y)`
 
 error: x.log(b) / y.log(b) can be reduced to x.log(y)
-  --> $DIR/floating_point_arithmetic.rs:106:13
+  --> $DIR/floating_point_log.rs:64:13
    |
 LL |     let _ = x.log(b) / y.log(b);
    |             ^^^^^^^^^^^^^^^^^^^ help: consider using: `x.log(y)`
 
 error: x.log(b) / y.log(b) can be reduced to x.log(y)
-  --> $DIR/floating_point_arithmetic.rs:108:13
+  --> $DIR/floating_point_log.rs:66:13
    |
 LL |     let _ = x.log(b) / 2f64.log(b);
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.log2()`
 
-error: aborting due to 44 previous errors
+error: aborting due to 28 previous errors
 
diff --git a/tests/ui/floating_point_powf.rs b/tests/ui/floating_point_powf.rs
new file mode 100644
index 00000000000..14f1f531f0f
--- /dev/null
+++ b/tests/ui/floating_point_powf.rs
@@ -0,0 +1,27 @@
+#![warn(clippy::floating_point_improvements)]
+
+fn main() {
+    let x = 3f32;
+    let _ = 2f32.powf(x);
+    let _ = std::f32::consts::E.powf(x);
+    let _ = x.powf(1.0 / 2.0);
+    let _ = x.powf(1.0 / 3.0);
+    let _ = x.powf(2.0);
+    let _ = x.powf(-2.0);
+    let _ = x.powf(2.1);
+    let _ = x.powf(-2.1);
+    let _ = x.powf(16_777_217.0);
+    let _ = x.powf(-16_777_217.0);
+
+    let x = 3f64;
+    let _ = 2f64.powf(x);
+    let _ = std::f64::consts::E.powf(x);
+    let _ = x.powf(1.0 / 2.0);
+    let _ = x.powf(1.0 / 3.0);
+    let _ = x.powf(2.0);
+    let _ = x.powf(-2.0);
+    let _ = x.powf(2.1);
+    let _ = x.powf(-2.1);
+    let _ = x.powf(9_007_199_254_740_993.0);
+    let _ = x.powf(-9_007_199_254_740_993.0);
+}
diff --git a/tests/ui/floating_point_powf.stderr b/tests/ui/floating_point_powf.stderr
new file mode 100644
index 00000000000..2be54af96c6
--- /dev/null
+++ b/tests/ui/floating_point_powf.stderr
@@ -0,0 +1,76 @@
+error: exponent for bases 2 and e can be computed more accurately
+  --> $DIR/floating_point_powf.rs:5:13
+   |
+LL |     let _ = 2f32.powf(x);
+   |             ^^^^^^^^^^^^ help: consider using: `x.exp2()`
+   |
+   = note: `-D clippy::floating-point-improvements` implied by `-D warnings`
+
+error: exponent for bases 2 and e can be computed more accurately
+  --> $DIR/floating_point_powf.rs:6:13
+   |
+LL |     let _ = std::f32::consts::E.powf(x);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.exp()`
+
+error: square-root of a number can be computed more efficiently and accurately
+  --> $DIR/floating_point_powf.rs:7:13
+   |
+LL |     let _ = x.powf(1.0 / 2.0);
+   |             ^^^^^^^^^^^^^^^^^ help: consider using: `x.sqrt()`
+
+error: cube-root of a number can be computed more accurately
+  --> $DIR/floating_point_powf.rs:8:13
+   |
+LL |     let _ = x.powf(1.0 / 3.0);
+   |             ^^^^^^^^^^^^^^^^^ help: consider using: `x.cbrt()`
+
+error: exponentiation with integer powers can be computed more efficiently
+  --> $DIR/floating_point_powf.rs:9:13
+   |
+LL |     let _ = x.powf(2.0);
+   |             ^^^^^^^^^^^ help: consider using: `x.powi(2)`
+
+error: exponentiation with integer powers can be computed more efficiently
+  --> $DIR/floating_point_powf.rs:10:13
+   |
+LL |     let _ = x.powf(-2.0);
+   |             ^^^^^^^^^^^^ help: consider using: `x.powi(-2)`
+
+error: exponent for bases 2 and e can be computed more accurately
+  --> $DIR/floating_point_powf.rs:17:13
+   |
+LL |     let _ = 2f64.powf(x);
+   |             ^^^^^^^^^^^^ help: consider using: `x.exp2()`
+
+error: exponent for bases 2 and e can be computed more accurately
+  --> $DIR/floating_point_powf.rs:18:13
+   |
+LL |     let _ = std::f64::consts::E.powf(x);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.exp()`
+
+error: square-root of a number can be computed more efficiently and accurately
+  --> $DIR/floating_point_powf.rs:19:13
+   |
+LL |     let _ = x.powf(1.0 / 2.0);
+   |             ^^^^^^^^^^^^^^^^^ help: consider using: `x.sqrt()`
+
+error: cube-root of a number can be computed more accurately
+  --> $DIR/floating_point_powf.rs:20:13
+   |
+LL |     let _ = x.powf(1.0 / 3.0);
+   |             ^^^^^^^^^^^^^^^^^ help: consider using: `x.cbrt()`
+
+error: exponentiation with integer powers can be computed more efficiently
+  --> $DIR/floating_point_powf.rs:21:13
+   |
+LL |     let _ = x.powf(2.0);
+   |             ^^^^^^^^^^^ help: consider using: `x.powi(2)`
+
+error: exponentiation with integer powers can be computed more efficiently
+  --> $DIR/floating_point_powf.rs:22:13
+   |
+LL |     let _ = x.powf(-2.0);
+   |             ^^^^^^^^^^^^ help: consider using: `x.powi(-2)`
+
+error: aborting due to 12 previous errors
+
generated by cgit-pink 1.4.1-3-g733a5 (git 2.37.1) at 2026-04-25 17:41:44 +0000