Merge pull request #327 from tgross35/config-rustfmt

Add a rustfmt.toml file matching rust-lang/rust

Author: tgross35

.git-blame-ignore-revs

@@ -0,0 +1,5 @@
+# Use `git config blame.ignorerevsfile .git-blame-ignore-revs` to make
+# `git blame` ignore the following commits.
+
+# Reformat with a new `.rustfmt.toml`
+5882cabb83c30bf7c36023f9a55a80583636b0e8

.github/workflows/main.yml

@@ -41,7 +41,7 @@ jobs:
     steps:
     - uses: actions/checkout@master
     - name: Install Rust
-      run: rustup update stable && rustup default stable && rustup component add rustfmt
+      run: rustup update nightly && rustup default nightly && rustup component add rustfmt
     - run: cargo fmt -- --check
 
   wasm:

.rustfmt.toml

@@ -0,0 +1,5 @@
+# This matches rustc
+style_edition = "2024"
+use_small_heuristics = "Max"
+group_imports = "StdExternalCrate"
+imports_granularity = "Module"

crates/libm-test/build.rs

@@ -5,12 +5,12 @@ fn main() {
 
 #[cfg(feature = "test-musl-serialized")]
 mod musl_reference_tests {
-    use rand::seq::SliceRandom;
-    use rand::Rng;
-    use std::env;
-    use std::fs;
     use std::path::PathBuf;
     use std::process::Command;
+    use std::{env, fs};
+
+    use rand::Rng;
+    use rand::seq::SliceRandom;
 
     // Number of tests to generate for each function
     const NTESTS: usize = 500;
@@ -60,10 +60,7 @@ mod musl_reference_tests {
             return;
         }
 
-        let files = fs::read_dir(math_src)
-            .unwrap()
-            .map(|f| f.unwrap().path())
-            .collect::<Vec<_>>();
+        let files = fs::read_dir(math_src).unwrap().map(|f| f.unwrap().path()).collect::<Vec<_>>();
 
         let mut math = Vec::new();
         for file in files {
@@ -112,12 +109,7 @@ mod musl_reference_tests {
         let tail = eat(tail, " -> ");
         let ret = parse_retty(tail.replace("{", "").trim());
 
-        return Function {
-            name: name.to_string(),
-            args,
-            ret,
-            tests: Vec::new(),
-        };
+        return Function { name: name.to_string(), args, ret, tests: Vec::new() };
 
         fn parse_ty(s: &str) -> Ty {
             match s {
@@ -156,11 +148,7 @@ mod musl_reference_tests {
         }
 
         fn generate_test<R: Rng>(function: &Function, rng: &mut R) -> Test {
-            let mut inputs = function
-                .args
-                .iter()
-                .map(|ty| ty.gen_i64(rng))
-                .collect::<Vec<_>>();
+            let mut inputs = function.args.iter().map(|ty| ty.gen_i64(rng)).collect::<Vec<_>>();
 
             // First argument to this function appears to be a number of
             // iterations, so passing in massive random numbers causes it to
@@ -180,25 +168,20 @@ mod musl_reference_tests {
 
     impl Ty {
         fn gen_i64<R: Rng>(&self, r: &mut R) -> i64 {
-            use std::f32;
-            use std::f64;
+            use std::{f32, f64};
 
             return match self {
                 Ty::F32 => {
                     if r.gen_range(0..20) < 1 {
-                        let i = *[f32::NAN, f32::INFINITY, f32::NEG_INFINITY]
-                            .choose(r)
-                            .unwrap();
+                        let i = *[f32::NAN, f32::INFINITY, f32::NEG_INFINITY].choose(r).unwrap();
                         i.to_bits().into()
                     } else {
                         r.gen::<f32>().to_bits().into()
                     }
                 }
                 Ty::F64 => {
                     if r.gen_range(0..20) < 1 {
-                        let i = *[f64::NAN, f64::INFINITY, f64::NEG_INFINITY]
-                            .choose(r)
-                            .unwrap();
+                        let i = *[f64::NAN, f64::INFINITY, f64::NEG_INFINITY].choose(r).unwrap();
                         i.to_bits() as i64
                     } else {
                         r.gen::<f64>().to_bits() as i64
@@ -424,11 +407,7 @@ mod musl_reference_tests {
             src.push_str(");");
 
             for (i, ret) in function.ret.iter().enumerate() {
-                let get = if function.ret.len() == 1 {
-                    String::new()
-                } else {
-                    format!(".{}", i)
-                };
+                let get = if function.ret.len() == 1 { String::new() } else { format!(".{}", i) };
                 src.push_str(&(match ret {
                     Ty::F32 => format!("if libm::_eqf(output{}, f32::from_bits(expected[{}] as u32)).is_ok() {{ continue }}", get, i),
                     Ty::F64 => format!("if libm::_eq(output{}, f64::from_bits(expected[{}] as u64)).is_ok() {{ continue }}", get, i),

src/lib.rs

@@ -17,9 +17,10 @@ mod math;
 
 use core::{f32, f64};
 
-pub use self::math::*;
 pub use libm_helper::*;
 
+pub use self::math::*;
+
 /// Approximate equality with 1 ULP of tolerance
 #[doc(hidden)]
 #[inline]
@@ -29,11 +30,7 @@ pub fn _eqf(a: f32, b: f32) -> Result<(), u32> {
     } else {
         let err = (a.to_bits() as i32).wrapping_sub(b.to_bits() as i32).abs();
 
-        if err <= 1 {
-            Ok(())
-        } else {
-            Err(err as u32)
-        }
+        if err <= 1 { Ok(()) } else { Err(err as u32) }
     }
 }
 
@@ -45,10 +42,6 @@ pub fn _eq(a: f64, b: f64) -> Result<(), u64> {
     } else {
         let err = (a.to_bits() as i64).wrapping_sub(b.to_bits() as i64).abs();
 
-        if err <= 1 {
-            Ok(())
-        } else {
-            Err(err as u64)
-        }
+        if err <= 1 { Ok(()) } else { Err(err as u64) }
     }
 }

src/math/asin.rs

@@ -111,9 +111,5 @@ pub fn asin(mut x: f64) -> f64 {
         c = (z - f * f) / (s + f);
         x = 0.5 * PIO2_HI - (2.0 * s * r - (PIO2_LO - 2.0 * c) - (0.5 * PIO2_HI - 2.0 * f));
     }
-    if hx >> 31 != 0 {
-        -x
-    } else {
-        x
-    }
+    if hx >> 31 != 0 { -x } else { x }
 }

src/math/asinf.rs

@@ -64,9 +64,5 @@ pub fn asinf(mut x: f32) -> f32 {
     let z = (1. - fabsf(x)) * 0.5;
     let s = sqrt(z as f64);
     x = (PIO2 - 2. * (s + s * (r(z) as f64))) as f32;
-    if (hx >> 31) != 0 {
-        -x
-    } else {
-        x
-    }
+    if (hx >> 31) != 0 { -x } else { x }
 }

src/math/asinh.rs

@@ -32,9 +32,5 @@ pub fn asinh(mut x: f64) -> f64 {
         force_eval!(x + x1p120);
     }
 
-    if sign {
-        -x
-    } else {
-        x
-    }
+    if sign { -x } else { x }
 }

src/math/asinhf.rs

@@ -31,9 +31,5 @@ pub fn asinhf(mut x: f32) -> f32 {
         force_eval!(x + x1p120);
     }
 
-    if sign {
-        -x
-    } else {
-        x
-    }
+    if sign { -x } else { x }
 }

src/math/atan.rs

@@ -29,9 +29,10 @@
  * to produce the hexadecimal values shown.
  */
 
-use super::fabs;
 use core::f64;
 
+use super::fabs;
+
 const ATANHI: [f64; 4] = [
     4.63647609000806093515e-01, /* atan(0.5)hi 0x3FDDAC67, 0x0561BB4F */
     7.85398163397448278999e-01, /* atan(1.0)hi 0x3FE921FB, 0x54442D18 */
@@ -128,18 +129,15 @@ pub fn atan(x: f64) -> f64 {
 
     let z = i!(ATANHI, id as usize) - (x * (s1 + s2) - i!(ATANLO, id as usize) - x);
 
-    if sign != 0 {
-        -z
-    } else {
-        z
-    }
+    if sign != 0 { -z } else { z }
 }
 
 #[cfg(test)]
 mod tests {
-    use super::atan;
     use core::f64;
 
+    use super::atan;
+
     #[test]
     fn sanity_check() {
         for (input, answer) in [