Change imports to vertical

Author: AaronKutch

.rustfmt.toml

@@ -35,7 +35,7 @@ hard_tabs = false
 hide_parse_errors = false
 ignore = []
 imports_indent = "Block"
-imports_layout = "HorizontalVertical" # handles lots of imports better
+imports_layout = "Vertical" # makes editing quicker
 indent_style = "Block"
 inline_attribute_width = 0 # unchanged, for ease of editing
 # license_template_path = "LICENSE_TEMPLATE" # changed
@@ -71,4 +71,4 @@ use_small_heuristics = "Default"
 use_try_shorthand = true # changed
 version = "Two" # changed
 where_single_line = false # unchanged, for ease of editing
-wrap_comments = true # fits comments to the line
+wrap_comments = true # fits comments to the line

src/apint/arithmetic.rs

@@ -3,18 +3,42 @@ use crate::{
         utils::{
             DataAccessMut,
             ZipDataAccessMutBoth,
-            ZipDataAccessMutSelf::{Ext, Inl},
+            ZipDataAccessMutSelf::{
+                Ext,
+                Inl,
+            },
         },
         ApInt,
     },
     digit,
-    digit::{Digit, DoubleDigit},
-    errors::{DivOp, Error, Result},
-    mem::{vec, vec::Vec},
+    digit::{
+        Digit,
+        DoubleDigit,
+    },
+    errors::{
+        DivOp,
+        Error,
+        Result,
+    },
+    mem::{
+        vec,
+        vec::Vec,
+    },
     traits::Width,
-    utils::{forward_mut_impl, try_forward_bin_mut_impl},
+    utils::{
+        forward_mut_impl,
+        try_forward_bin_mut_impl,
+    },
+};
+use core::ops::{
+    Add,
+    AddAssign,
+    Mul,
+    MulAssign,
+    Neg,
+    Sub,
+    SubAssign,
 };
-use core::ops::{Add, AddAssign, Mul, MulAssign, Neg, Sub, SubAssign};
 
 // Moved here because of a bug in rustfmt. This entire file will be broken up in
 // a future commit. assigns `$sum + $sub` to `$target`,
@@ -1915,7 +1939,10 @@ mod tests {
     mod mul {
         use super::*;
         use crate::bitwidth::BitWidth;
-        use core::{u64, u8};
+        use core::{
+            u64,
+            u8,
+        };
 
         #[test]
         fn rigorous() {

src/apint/bitwise.rs

@@ -1,6 +1,9 @@
 use crate::{
     apint::{
-        utils::{DataAccess, DataAccessMut},
+        utils::{
+            DataAccess,
+            DataAccessMut,
+        },
         ApInt,
     },
     bitpos::BitPos,
@@ -9,10 +12,21 @@ use crate::{
     digit::Bit,
     errors::Result,
     traits::Width,
-    utils::{forward_mut_impl, try_forward_bin_mut_impl},
+    utils::{
+        forward_mut_impl,
+        try_forward_bin_mut_impl,
+    },
 };
 
-use core::ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign, Not};
+use core::ops::{
+    BitAnd,
+    BitAndAssign,
+    BitOr,
+    BitOrAssign,
+    BitXor,
+    BitXorAssign,
+    Not,
+};
 
 /// # Bitwise Operations
 impl ApInt {

src/apint/casting.rs

@@ -2,11 +2,17 @@ use crate::{
     apint::ApInt,
     bitwidth::BitWidth,
     digit::Bit,
-    errors::{Error, Result},
+    errors::{
+        Error,
+        Result,
+    },
     mem::format,
     storage::Storage,
     traits::Width,
-    utils::{forward_bin_mut_impl, try_forward_bin_mut_impl},
+    utils::{
+        forward_bin_mut_impl,
+        try_forward_bin_mut_impl,
+    },
 };
 
 impl Clone for ApInt {
@@ -732,7 +738,10 @@ mod tests {
 
         #[test]
         fn regression_issue15() {
-            use core::{i128, i64};
+            use core::{
+                i128,
+                i64,
+            };
             {
                 let input = ApInt::from_i64(i64::MIN)
                     .into_sign_extend(BitWidth::new(128).unwrap())

src/apint/constructors.rs

@@ -1,9 +1,18 @@
 use crate::{
-    apint::{ApInt, ApIntData},
+    apint::{
+        ApInt,
+        ApIntData,
+    },
     bitwidth::BitWidth,
     digit,
-    digit::{Bit, Digit},
-    errors::{Error, Result},
+    digit::{
+        Bit,
+        Digit,
+    },
+    errors::{
+        Error,
+        Result,
+    },
     mem::vec::Vec,
     storage::Storage,
 };
@@ -422,7 +431,10 @@ mod tests {
     }
 
     mod tests {
-        use super::{powers, powers_from_to};
+        use super::{
+            powers,
+            powers_from_to,
+        };
 
         #[test]
         fn test_powers() {
@@ -616,7 +628,10 @@ mod tests {
 
     #[test]
     fn from_w128() {
-        use crate::digit::{Digit, DigitRepr};
+        use crate::digit::{
+            Digit,
+            DigitRepr,
+        };
         for val in test_values_u128() {
             let explicit_u128 = ApInt::from_u128(val);
             let explicit_i128 = ApInt::from_i128(val as i128);

src/apint/mod.rs

@@ -14,7 +14,10 @@ mod rand_impl;
 #[cfg(feature = "serde_support")]
 mod serde_impl;
 
-use crate::{bitwidth::BitWidth, digit::Digit};
+use crate::{
+    bitwidth::BitWidth,
+    digit::Digit,
+};
 
 pub use self::shift::ShiftAmount;
 pub(crate) use self::to_primitive::PrimitiveTy;

src/apint/rand_impl.rs

@@ -1,4 +1,8 @@
-use crate::{apint::ApInt, bitwidth::BitWidth, digit::Digit};
+use crate::{
+    apint::ApInt,
+    bitwidth::BitWidth,
+    digit::Digit,
+};
 use rand::SeedableRng as _;
 
 impl rand::distributions::Distribution<Digit> for rand::distributions::Standard {
@@ -28,7 +32,10 @@ impl ApInt {
     {
         let required_digits = width.required_digits();
         assert!(required_digits >= 1);
-        use rand::distributions::{Distribution, Standard};
+        use rand::distributions::{
+            Distribution,
+            Standard,
+        };
         let random_digits = Standard.sample_iter(rng).take(required_digits);
         // The truncation will be cheap always!
         ApInt::from_iter(random_digits)
@@ -58,7 +65,10 @@ impl ApInt {
     where
         R: rand::Rng,
     {
-        use rand::distributions::{Distribution, Standard};
+        use rand::distributions::{
+            Distribution,
+            Standard,
+        };
         let std_dist = Standard.sample_iter(rng);
         self.digits_mut().zip(std_dist).for_each(|(d, r)| *d = r);
         self.clear_unused_bits();

src/apint/relational.rs

@@ -1,12 +1,18 @@
 use crate::{
-    apint::{utils::ZipDataAccess, ApInt},
+    apint::{
+        utils::ZipDataAccess,
+        ApInt,
+    },
     digit,
     digit::Bit,
     errors::Result,
     mem::format,
     traits::Width,
 };
-use core::{cmp::Ordering, ops::Not};
+use core::{
+    cmp::Ordering,
+    ops::Not,
+};
 
 /// If `self` and `other` have unmatching bit widths, `false` will be returned.
 impl PartialEq for ApInt {

src/apint/serde_impl.rs

@@ -1,6 +1,14 @@
-use crate::{apint::ApInt, bitwidth::BitWidth, digit::Digit};
+use crate::{
+    apint::ApInt,
+    bitwidth::BitWidth,
+    digit::Digit,
+};
 
-use serde::{ser::SerializeTupleStruct, Serialize, Serializer};
+use serde::{
+    ser::SerializeTupleStruct,
+    Serialize,
+    Serializer,
+};
 
 impl Serialize for Digit {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -31,7 +39,10 @@ impl Serialize for ApInt {
     where
         S: Serializer,
     {
-        use serde::ser::{SerializeStruct, SerializeTuple};
+        use serde::ser::{
+            SerializeStruct,
+            SerializeTuple,
+        };
 
         if serializer.is_human_readable() {
             let mut s = serializer.serialize_struct("ApInt", 2)?;
@@ -50,7 +61,11 @@ impl Serialize for ApInt {
 use core::fmt;
 use serde::{
     de,
-    de::{MapAccess, SeqAccess, Visitor},
+    de::{
+        MapAccess,
+        SeqAccess,
+        Visitor,
+    },
     Deserialize,
     Deserializer,
 };
@@ -296,7 +311,10 @@ impl<'de> Deserialize<'de> for ApInt {
 mod tests {
     use super::*;
 
-    use serde_test::{assert_tokens, Token};
+    use serde_test::{
+        assert_tokens,
+        Token,
+    };
 
     mod compact {
         use super::*;

src/apint/serialization.rs

@@ -1,8 +1,14 @@
 use crate::{
     apint::ApInt,
     digit,
-    errors::{Error, Result},
-    mem::{string::String, vec::Vec},
+    errors::{
+        Error,
+        Result,
+    },
+    mem::{
+        string::String,
+        vec::Vec,
+    },
     radix::Radix,
 };
 use core::fmt;
@@ -190,7 +196,10 @@ impl ApInt {
     //
     // TODO: Better document what happens here and why.
     fn from_bitwise_digits(v: &[u8], bits: usize) -> ApInt {
-        use crate::digit::{Digit, DigitRepr};
+        use crate::digit::{
+            Digit,
+            DigitRepr,
+        };
 
         debug_assert!(!v.is_empty() && bits <= 8 && digit::BITS % bits == 0);
         debug_assert!(v.iter().all(|&c| DigitRepr::from(c) < (1 << bits)));
@@ -217,7 +226,10 @@ impl ApInt {
     //
     // TODO: Better document what happens here and why.
     fn from_inexact_bitwise_digits(v: &[u8], bits: usize) -> ApInt {
-        use crate::digit::{Digit, DigitRepr};
+        use crate::digit::{
+            Digit,
+            DigitRepr,
+        };
 
         debug_assert!(!v.is_empty() && bits <= 8 && digit::BITS % bits != 0);
         debug_assert!(v.iter().all(|&c| (DigitRepr::from(c)) < (1 << bits)));
@@ -259,7 +271,10 @@ impl ApInt {
     // TODO: This does not work, yet. Some parts of the algorithm are
     //       commented-out since the required functionality does not exist, yet.
     fn from_radix_digits(v: &[u8], radix: Radix) -> ApInt {
-        use crate::digit::{Digit, DigitRepr};
+        use crate::digit::{
+            Digit,
+            DigitRepr,
+        };
         #[cfg(feature = "libm_0")]
         use libm::F64Ext as _;