Reformat using the new identifier sorting from rustfmt

3 files changed, 42 insertions, 50 deletions

diff --git a/compiler/rustc_index/src/bit_set.rs b/compiler/rustc_index/src/bit_set.rs
index 506afbae40c..c2b9cae680b 100644
--- a/compiler/rustc_index/src/bit_set.rs
+++ b/compiler/rustc_index/src/bit_set.rs
@@ -3,11 +3,11 @@ use std::ops::{BitAnd, BitAndAssign, BitOrAssign, Bound, Not, Range, RangeBounds
 use std::rc::Rc;
 use std::{fmt, iter, mem, slice};
 
+use Chunk::*;
 use arrayvec::ArrayVec;
 #[cfg(feature = "nightly")]
 use rustc_macros::{Decodable_Generic, Encodable_Generic};
-use smallvec::{smallvec, SmallVec};
-use Chunk::*;
+use smallvec::{SmallVec, smallvec};
 
 use crate::{Idx, IndexVec};
 
diff --git a/compiler/rustc_index/src/bit_set/tests.rs b/compiler/rustc_index/src/bit_set/tests.rs
index 066aa46e350..21e681d63f6 100644
--- a/compiler/rustc_index/src/bit_set/tests.rs
+++ b/compiler/rustc_index/src/bit_set/tests.rs
@@ -182,10 +182,11 @@ fn chunked_bitset() {
     //-----------------------------------------------------------------------
 
     let mut b1 = ChunkedBitSet::<usize>::new_empty(1);
-    assert_eq!(
-        b1,
-        ChunkedBitSet { domain_size: 1, chunks: Box::new([Zeros(1)]), marker: PhantomData }
-    );
+    assert_eq!(b1, ChunkedBitSet {
+        domain_size: 1,
+        chunks: Box::new([Zeros(1)]),
+        marker: PhantomData
+    });
 
     b1.assert_valid();
     assert!(!b1.contains(0));
@@ -204,10 +205,11 @@ fn chunked_bitset() {
     //-----------------------------------------------------------------------
 
     let mut b100 = ChunkedBitSet::<usize>::new_filled(100);
-    assert_eq!(
-        b100,
-        ChunkedBitSet { domain_size: 100, chunks: Box::new([Ones(100)]), marker: PhantomData }
-    );
+    assert_eq!(b100, ChunkedBitSet {
+        domain_size: 100,
+        chunks: Box::new([Ones(100)]),
+        marker: PhantomData
+    });
 
     b100.assert_valid();
     for i in 0..100 {
@@ -222,20 +224,17 @@ fn chunked_bitset() {
     );
     assert_eq!(b100.count(), 97);
     assert!(!b100.contains(20) && b100.contains(30) && !b100.contains(99) && b100.contains(50));
-    assert_eq!(
-        b100.chunks(),
-        vec![Mixed(
-            100,
-            97,
-            #[rustfmt::skip]
+    assert_eq!(b100.chunks(), vec![Mixed(
+        100,
+        97,
+        #[rustfmt::skip]
             Rc::new([
                 0b11111111_11111111_11111110_11111111_11111111_11101111_11111111_11111111,
                 0b00000000_00000000_00000000_00000111_11111111_11111111_11111111_11111111,
                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                 0, 0, 0, 0, 0,
             ])
-        )],
-    );
+    )],);
     b100.assert_valid();
     let mut num_removed = 0;
     for i in 0..100 {
@@ -250,14 +249,11 @@ fn chunked_bitset() {
     //-----------------------------------------------------------------------
 
     let mut b2548 = ChunkedBitSet::<usize>::new_empty(2548);
-    assert_eq!(
-        b2548,
-        ChunkedBitSet {
-            domain_size: 2548,
-            chunks: Box::new([Zeros(2048), Zeros(500)]),
-            marker: PhantomData,
-        }
-    );
+    assert_eq!(b2548, ChunkedBitSet {
+        domain_size: 2548,
+        chunks: Box::new([Zeros(2048), Zeros(500)]),
+        marker: PhantomData,
+    });
 
     b2548.assert_valid();
     b2548.insert(14);
@@ -274,14 +270,11 @@ fn chunked_bitset() {
     //-----------------------------------------------------------------------
 
     let mut b4096 = ChunkedBitSet::<usize>::new_empty(4096);
-    assert_eq!(
-        b4096,
-        ChunkedBitSet {
-            domain_size: 4096,
-            chunks: Box::new([Zeros(2048), Zeros(2048)]),
-            marker: PhantomData,
-        }
-    );
+    assert_eq!(b4096, ChunkedBitSet {
+        domain_size: 4096,
+        chunks: Box::new([Zeros(2048), Zeros(2048)]),
+        marker: PhantomData,
+    });
 
     b4096.assert_valid();
     for i in 0..4096 {
@@ -311,14 +304,11 @@ fn chunked_bitset() {
     //-----------------------------------------------------------------------
 
     let mut b10000 = ChunkedBitSet::<usize>::new_empty(10000);
-    assert_eq!(
-        b10000,
-        ChunkedBitSet {
-            domain_size: 10000,
-            chunks: Box::new([Zeros(2048), Zeros(2048), Zeros(2048), Zeros(2048), Zeros(1808),]),
-            marker: PhantomData,
-        }
-    );
+    assert_eq!(b10000, ChunkedBitSet {
+        domain_size: 10000,
+        chunks: Box::new([Zeros(2048), Zeros(2048), Zeros(2048), Zeros(2048), Zeros(1808),]),
+        marker: PhantomData,
+    });
 
     b10000.assert_valid();
     assert!(b10000.insert(3000) && b10000.insert(5000));
diff --git a/compiler/rustc_index/src/vec/tests.rs b/compiler/rustc_index/src/vec/tests.rs
index 381d79c24fc..9cee2f2f5b2 100644
--- a/compiler/rustc_index/src/vec/tests.rs
+++ b/compiler/rustc_index/src/vec/tests.rs
@@ -29,19 +29,21 @@ fn index_size_is_optimized() {
 #[test]
 fn range_iterator_iterates_forwards() {
     let range = MyIdx::from_u32(1)..MyIdx::from_u32(4);
-    assert_eq!(
-        range.collect::<Vec<_>>(),
-        [MyIdx::from_u32(1), MyIdx::from_u32(2), MyIdx::from_u32(3)]
-    );
+    assert_eq!(range.collect::<Vec<_>>(), [
+        MyIdx::from_u32(1),
+        MyIdx::from_u32(2),
+        MyIdx::from_u32(3)
+    ]);
 }
 
 #[test]
 fn range_iterator_iterates_backwards() {
     let range = MyIdx::from_u32(1)..MyIdx::from_u32(4);
-    assert_eq!(
-        range.rev().collect::<Vec<_>>(),
-        [MyIdx::from_u32(3), MyIdx::from_u32(2), MyIdx::from_u32(1)]
-    );
+    assert_eq!(range.rev().collect::<Vec<_>>(), [
+        MyIdx::from_u32(3),
+        MyIdx::from_u32(2),
+        MyIdx::from_u32(1)
+    ]);
 }
 
 #[test]