liballoc: revert nested imports style changes.

Author: Centril

src/liballoc/alloc.rs

@@ -2,11 +2,9 @@
 
 #![stable(feature = "alloc_module", since = "1.28.0")]
 
-use core::{
-    intrinsics::{min_align_of_val, size_of_val},
-    ptr::{NonNull, Unique},
-    usize,
-};
+use core::intrinsics::{min_align_of_val, size_of_val};
+use core::ptr::{NonNull, Unique};
+use core::usize;
 
 #[stable(feature = "alloc_module", since = "1.28.0")]
 #[doc(inline)]
@@ -230,10 +228,8 @@ pub fn handle_alloc_error(layout: Layout) -> ! {
 mod tests {
     extern crate test;
     use test::Bencher;
-    use crate::{
-        boxed::Box,
-        alloc::{Global, Alloc, Layout, handle_alloc_error},
-    };
+    use crate::boxed::Box;
+    use crate::alloc::{Global, Alloc, Layout, handle_alloc_error};
 
     #[test]
     fn allocate_zeroed() {

src/liballoc/benches/btree/map.rs

@@ -1,8 +1,7 @@
-use std::{
-    iter::Iterator,
-    vec::Vec,
-    collections::BTreeMap,
-};
+use std::iter::Iterator;
+use std::vec::Vec;
+use std::collections::BTreeMap;
+
 use rand::{Rng, seq::SliceRandom, thread_rng};
 use test::{Bencher, black_box};
 

src/liballoc/benches/slice.rs

@@ -1,8 +1,7 @@
 use std::{mem, ptr};
-use rand::{
-    thread_rng, Rng, SeedableRng,
-    distributions::{Standard, Alphanumeric},
-};
+
+use rand::{thread_rng, Rng, SeedableRng};
+use rand::distributions::{Standard, Alphanumeric};
 use rand_xorshift::XorShiftRng;
 use test::{Bencher, black_box};
 

src/liballoc/borrow.rs

@@ -2,16 +2,15 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
-use core::{
-    cmp::Ordering,
-    hash::{Hash, Hasher},
-    ops::{Add, AddAssign, Deref},
-};
+use core::cmp::Ordering;
+use core::hash::{Hash, Hasher};
+use core::ops::{Add, AddAssign, Deref};
 
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use core::borrow::{Borrow, BorrowMut};
 
-use crate::{fmt, string::String};
+use crate::fmt;
+use crate::string::String;
 
 use Cow::*;
 

src/liballoc/boxed.rs

@@ -56,28 +56,26 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
-use core::{
-    any::Any,
-    borrow,
-    cmp::Ordering,
-    convert::From,
-    fmt,
-    future::Future,
-    hash::{Hash, Hasher},
-    iter::{Iterator, FromIterator, FusedIterator},
-    marker::{Unpin, Unsize},
-    mem,
-    pin::Pin,
-    ops::{CoerceUnsized, DispatchFromDyn, Deref, DerefMut, Receiver, Generator, GeneratorState},
-    ptr::{self, NonNull, Unique},
-    task::{LocalWaker, Poll},
+use core::any::Any;
+use core::borrow;
+use core::cmp::Ordering;
+use core::convert::From;
+use core::fmt;
+use core::future::Future;
+use core::hash::{Hash, Hasher};
+use core::iter::{Iterator, FromIterator, FusedIterator};
+use core::marker::{Unpin, Unsize};
+use core::mem;
+use core::pin::Pin;
+use core::ops::{
+    CoerceUnsized, DispatchFromDyn, Deref, DerefMut, Receiver, Generator, GeneratorState
 };
+use core::ptr::{self, NonNull, Unique};
+use core::task::{LocalWaker, Poll};
 
-use crate::{
-    vec::Vec,
-    raw_vec::RawVec,
-    str::from_boxed_utf8_unchecked,
-};
+use crate::vec::Vec;
+use crate::raw_vec::RawVec;
+use crate::str::from_boxed_utf8_unchecked;
 
 /// A pointer type for heap allocation.
 ///

src/liballoc/boxed_test.rs

@@ -1,13 +1,11 @@
 //! Test for `boxed` mod.
 
-use core::{
-    any::Any,
-    ops::Deref,
-    result::Result::{Err, Ok},
-    clone::Clone,
-    f64,
-    i64,
-};
+use core::any::Any;
+use core::ops::Deref;
+use core::result::Result::{Err, Ok};
+use core::clone::Clone;
+use core::f64;
+use core::i64;
 
 use std::boxed::Box;
 

src/liballoc/collections/binary_heap.rs

@@ -145,18 +145,14 @@
 #![allow(missing_docs)]
 #![stable(feature = "rust1", since = "1.0.0")]
 
-use core::{
-    ops::{Deref, DerefMut},
-    iter::{FromIterator, FusedIterator},
-    mem::{swap, size_of, ManuallyDrop},
-    ptr,
-    fmt,
-};
-
-use crate::{
-    slice,
-    vec::{self, Vec},
-};
+use core::ops::{Deref, DerefMut};
+use core::iter::{FromIterator, FusedIterator};
+use core::mem::{swap, size_of, ManuallyDrop};
+use core::ptr;
+use core::fmt;
+
+use crate::slice;
+use crate::vec::{self, Vec};
 
 use super::SpecExtend;
 

src/liballoc/collections/btree/map.rs

@@ -1,21 +1,15 @@
-use core::{
-    borrow::Borrow,
-    cmp::Ordering,
-    fmt::Debug,
-    hash::{Hash, Hasher},
-    iter::{FromIterator, Peekable, FusedIterator},
-    marker::PhantomData,
-    ops::{
-        Bound::{Excluded, Included, Unbounded},
-        Index, RangeBounds,
-    },
-    fmt, intrinsics, mem, ptr,
-};
-
-use super::{
-    node::{self, Handle, NodeRef, marker, InsertResult::*, ForceResult::*},
-    search::{self, SearchResult::*},
-};
+use core::borrow::Borrow;
+use core::cmp::Ordering;
+use core::fmt::Debug;
+use core::hash::{Hash, Hasher};
+use core::iter::{FromIterator, Peekable, FusedIterator};
+use core::marker::PhantomData;
+use core::ops::Bound::{Excluded, Included, Unbounded};
+use core::ops::{Index, RangeBounds};
+use core::{fmt, intrinsics, mem, ptr};
+
+use super::node::{self, Handle, NodeRef, marker, InsertResult::*, ForceResult::*};
+use super::search::{self, SearchResult::*};
 
 use UnderflowResult::*;
 use Entry::*;

src/liballoc/collections/btree/node.rs

@@ -31,17 +31,13 @@
 // - A node of length `n` has `n` keys, `n` values, and (in an internal node) `n + 1` edges.
 //   This implies that even an empty internal node has at least one edge.
 
-use core::{
-    marker::PhantomData,
-    mem::{self, MaybeUninit},
-    ptr::{self, Unique, NonNull},
-    slice,
-};
+use core::marker::PhantomData;
+use core::mem::{self, MaybeUninit};
+use core::ptr::{self, Unique, NonNull};
+use core::slice;
 
-use crate::{
-    alloc::{Global, Alloc, Layout},
-    boxed::Box,
-};
+use crate::alloc::{Global, Alloc, Layout};
+use crate::boxed::Box;
 
 const B: usize = 6;
 pub const MIN_LEN: usize = B - 1;

src/liballoc/collections/btree/search.rs

@@ -1,7 +1,5 @@
-use core::{
-    borrow::Borrow,
-    cmp::Ordering,
-};
+use core::borrow::Borrow;
+use core::cmp::Ordering;
 
 use super::node::{Handle, NodeRef, marker, ForceResult::*};