Add in our rust formatters.

Author: Alexhuszagh

extras/data-tests/src/main.rs

@@ -31,10 +31,7 @@ impl TestCase {
         let (value, len) = r.unwrap();
         if len != self.string.len() || value != expected {
             if len != self.string.len() {
-                eprintln!(
-                    "Expected empty string remainder, got: {:?}",
-                    self.string.len() - len
-                );
+                eprintln!("Expected empty string remainder, got: {:?}", self.string.len() - len);
             }
             if value != expected {
                 eprintln!("Expected output {}, got {}", expected, value);
@@ -51,10 +48,7 @@ impl TestCase {
 
 fn parse_test_file(filename: impl AsRef<Path>) -> impl Iterator<Item = TestCase> {
     let file = File::open(filename).unwrap();
-    BufReader::new(file)
-        .lines()
-        .map(Result::unwrap)
-        .map(TestCase::parse)
+    BufReader::new(file).lines().map(Result::unwrap).map(TestCase::parse)
 }
 
 fn run_test_cases(filename: impl AsRef<Path>) -> usize {

extras/simple-bench/src/main.rs

@@ -6,20 +6,14 @@ use std::path::{Path, PathBuf};
 use std::str::FromStr;
 use std::time::Instant;
 
+use fast_float2::FastFloat;
 use fastrand::Rng;
 use lexical::FromLexical;
-use structopt::StructOpt;
-
-use fast_float2::FastFloat;
-
 use random::RandomGen;
+use structopt::StructOpt;
 
 #[derive(Debug, StructOpt)]
-#[structopt(
-    name = "fast-float-simple-bench",
-    about = "fast-float benchmark utility",
-    no_version
-)]
+#[structopt(name = "fast-float-simple-bench", about = "fast-float benchmark utility", no_version)]
 struct Opt {
     /// Parse numbers as float32 (default is float64)
     #[structopt(short, long = "32")]
@@ -146,9 +140,7 @@ impl Method {
                 fast_float::parse_partial::<T, _>(s).unwrap_or_default().0
             }),
             Self::Lexical => run_bench(data, repeat, |s: &str| {
-                lexical_core::parse_partial::<T>(s.as_bytes())
-                    .unwrap_or_default()
-                    .0
+                lexical_core::parse_partial::<T>(s.as_bytes()).unwrap_or_default().0
             }),
             Self::FromStr => run_bench(data, repeat, |s: &str| s.parse::<T>().unwrap_or_default()),
         };
@@ -180,12 +172,8 @@ fn print_report(results: &[BenchResult], title: &str) {
     println!("| {:^width$} |", title, width = width);
     println!("|{:=<width$}|", "", width = width + 2);
     print_table("ns/float", results, width, |t, n, _| t as f64 / n as f64);
-    print_table("Mfloat/s", results, width, |t, n, _| {
-        1e3 * n as f64 / t as f64
-    });
-    print_table("MB/s", results, width, |t, _, b| {
-        b as f64 * 1e9 / 1024. / 1024. / t as f64
-    });
+    print_table("Mfloat/s", results, width, |t, n, _| 1e3 * n as f64 / t as f64);
+    print_table("MB/s", results, width, |t, _, b| b as f64 * 1e9 / 1024. / 1024. / t as f64);
     println!("|{:width$}|", "", width = width + 2);
     println!("{:=<width$}", "", width = width + 4);
 }
@@ -219,11 +207,7 @@ fn print_table(
     for res in results {
         print!("| {:<h$}", res.name, h = h);
         let (n, b) = (res.count, res.bytes);
-        let mut metrics = res
-            .times
-            .iter()
-            .map(|&t| transform(t, n, b))
-            .collect::<Vec<_>>();
+        let mut metrics = res.times.iter().map(|&t| transform(t, n, b)).collect::<Vec<_>>();
         metrics.sort_by(|a, b| a.partial_cmp(b).unwrap());
         for &(_, idx) in columns {
             print!("{:>w$.2}", metrics[idx], w = w);
@@ -240,23 +224,23 @@ struct Input {
 impl Input {
     pub fn from_file(filename: impl AsRef<Path>) -> Self {
         let filename = filename.as_ref();
-        let data = fs::read_to_string(&filename)
-            .unwrap()
-            .trim()
-            .lines()
-            .map(String::from)
-            .collect();
+        let data =
+            fs::read_to_string(&filename).unwrap().trim().lines().map(String::from).collect();
         let name = filename.file_name().unwrap().to_str().unwrap().into();
-        Self { data, name }
+        Self {
+            data,
+            name,
+        }
     }
 
     pub fn from_random(gen: RandomGen, count: usize, seed: u64) -> Self {
         let mut rng = Rng::with_seed(seed);
-        let data = iter::repeat_with(|| gen.gen(&mut rng))
-            .take(count)
-            .collect();
+        let data = iter::repeat_with(|| gen.gen(&mut rng)).take(count).collect();
         let name = format!("{}", gen);
-        Self { data, name }
+        Self {
+            data,
+            name,
+        }
     }
 
     pub fn count(&self) -> usize {
@@ -281,14 +265,16 @@ impl Input {
 fn main() {
     let opt: Opt = StructOpt::from_args();
 
-    let methods = if !opt.only_fast_float && !matches!(&opt.command, &Cmd::All {..}) {
+    let methods = if !opt.only_fast_float && !matches!(&opt.command, &Cmd::All { .. }) {
         Method::all().into()
     } else {
         vec![Method::FastFloat2]
     };
 
     let inputs = match opt.command {
-        Cmd::File { filename } => vec![Input::from_file(filename)],
+        Cmd::File {
+            filename,
+        } => vec![Input::from_file(filename)],
         Cmd::Random {
             gen,
             count,
@@ -300,8 +286,11 @@ fn main() {
                 fs::write(filename, input.data.join("\n")).unwrap();
             }
             vec![input]
-        }
-        Cmd::All { count, seed } => {
+        },
+        Cmd::All {
+            count,
+            seed,
+        } => {
             let mut inputs = vec![];
             let data_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("ext/data");
             inputs.push(Input::from_file(data_dir.join("mesh.txt")));
@@ -310,7 +299,7 @@ fn main() {
                 inputs.push(Input::from_random(gen, count, seed))
             }
             inputs
-        }
+        },
     };
 
     let mut results = vec![];

rustfmt.toml

@@ -0,0 +1,19 @@
+# Requires nightly to do proper formatting.
+use_small_heuristics = "Off"
+use_field_init_shorthand = true
+trailing_semicolon = true
+newline_style = "Unix"
+match_block_trailing_comma = true
+empty_item_single_line = false
+enum_discrim_align_threshold = 40
+fn_params_layout = "Tall"
+fn_single_line = false
+format_macro_matchers = true
+format_macro_bodies = true
+imports_indent = "Block"
+imports_layout = "HorizontalVertical"
+indent_style = "Block"
+match_arm_blocks = true
+overflow_delimited_expr = true
+group_imports = "StdExternalCrate"
+wrap_comments = true

src/binary.rs

@@ -33,7 +33,10 @@ pub fn compute_float<F: Float>(q: i64, mut w: u64) -> AdjustedMantissa {
         mantissa += mantissa & 1;
         mantissa >>= 1;
         power2 = (mantissa >= (1_u64 << F::MANTISSA_EXPLICIT_BITS)) as i32;
-        return AdjustedMantissa { mantissa, power2 };
+        return AdjustedMantissa {
+            mantissa,
+            power2,
+        };
     }
     if lo <= 1
         && q >= F::MIN_EXPONENT_ROUND_TO_EVEN as i64
@@ -53,7 +56,10 @@ pub fn compute_float<F: Float>(q: i64, mut w: u64) -> AdjustedMantissa {
     if power2 >= F::INFINITE_POWER {
         return am_inf;
     }
-    AdjustedMantissa { mantissa, power2 }
+    AdjustedMantissa {
+        mantissa,
+        power2,
+    }
 }
 
 #[inline]
@@ -67,9 +73,10 @@ fn full_multiplication(a: u64, b: u64) -> (u64, u64) {
     (r as u64, (r >> 64) as u64)
 }
 
-// This will compute or rather approximate w * 5**q and return a pair of 64-bit words
-// approximating the result, with the "high" part corresponding to the most significant
-// bits and the low part corresponding to the least significant bits.
+// This will compute or rather approximate w * 5**q and return a pair of 64-bit
+// words approximating the result, with the "high" part corresponding to the
+// most significant bits and the low part corresponding to the least significant
+// bits.
 #[inline]
 fn compute_product_approx(q: i64, w: u64, precision: usize) -> (u64, u64) {
     debug_assert!(q >= SMALLEST_POWER_OF_FIVE as i64);

src/common.rs

@@ -27,7 +27,10 @@ impl<'a> AsciiStr<'a> {
     /// Safe if `n <= self.len()`
     #[inline]
     pub unsafe fn step_by(&mut self, n: usize) -> &mut Self {
-        debug_assert!(n <= self.len(), "buffer overflow: stepping by greater than our buffer length.");
+        debug_assert!(
+            n <= self.len(),
+            "buffer overflow: stepping by greater than our buffer length."
+        );
         // SAFETY: Safe if `n <= self.len()`
         unsafe { self.ptr = self.ptr.add(n) };
         self
@@ -102,10 +105,12 @@ impl<'a> AsciiStr<'a> {
 
     #[inline]
     pub fn first_digit(&self) -> Option<u8> {
-        self.first().and_then(|x| if x.is_ascii_digit() {
-            Some(x - b'0')
-        } else {
-            None
+        self.first().and_then(|x| {
+            if x.is_ascii_digit() {
+                Some(x - b'0')
+            } else {
+                None
+            }
         })
     }
 
@@ -153,7 +158,8 @@ impl<'a> AsciiStr<'a> {
     }
 }
 
-// Most of these are inherently unsafe; we assume we know what we're calling and when.
+// Most of these are inherently unsafe; we assume we know what we're calling and
+// when.
 pub trait ByteSlice: AsRef<[u8]> + AsMut<[u8]> {
     #[inline]
     fn check_first(&self, c: u8) -> bool {
@@ -216,7 +222,8 @@ pub trait ByteSlice: AsRef<[u8]> + AsMut<[u8]> {
     }
 }
 
-impl ByteSlice for [u8] {}
+impl ByteSlice for [u8] {
+}
 
 #[inline]
 pub fn is_8digits(v: u64) -> bool {

src/decimal.rs

@@ -33,7 +33,8 @@ impl PartialEq for Decimal {
     }
 }
 
-impl Eq for Decimal {}
+impl Eq for Decimal {
+}
 
 impl Default for Decimal {
     fn default() -> Self {
@@ -253,7 +254,11 @@ pub fn parse_decimal(mut s: &[u8]) -> Decimal {
                 exp_num = 10 * exp_num + digit as i32;
             }
         });
-        d.decimal_point += if neg_exp { -exp_num } else { exp_num };
+        d.decimal_point += if neg_exp {
+            -exp_num
+        } else {
+            exp_num
+        };
     }
     for i in d.num_digits..Decimal::MAX_DIGITS_WITHOUT_OVERFLOW {
         d.digits[i] = 0;

src/float.rs

@@ -45,7 +45,8 @@ pub trait Float:
     fn pow10_fast_path(exponent: usize) -> Self;
 }
 
-impl private::Sealed for f32 {}
+impl private::Sealed for f32 {
+}
 
 impl Float for f32 {
     const INFINITY: Self = core::f32::INFINITY;
@@ -78,14 +79,14 @@ impl Float for f32 {
     #[inline]
     fn pow10_fast_path(exponent: usize) -> Self {
         #[allow(clippy::use_self)]
-        const TABLE: [f32; 16] = [
-            1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 0., 0., 0., 0., 0.,
-        ];
+        const TABLE: [f32; 16] =
+            [1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 0., 0., 0., 0., 0.];
         TABLE[exponent & 15]
     }
 }
 
-impl private::Sealed for f64 {}
+impl private::Sealed for f64 {
+}
 
 impl Float for f64 {
     const INFINITY: Self = core::f64::INFINITY;