chore(rustfmt): replace configs for new rls-rustfmt

Author: Evan Cameron

alarm_base/src/frame.rs

@@ -3,7 +3,6 @@ use alloc::allocator::AllocErr;
 
 /// An allocator that provides page frames.
 pub unsafe trait Allocator {
-  
     /// Architecture-dependent size of a physical page.
     const FRAME_SIZE: usize;
 
@@ -21,9 +20,8 @@ pub unsafe trait Allocator {
     /// # Unsafety
     /// This function is unsafe because undefined behaviour may result if the
     /// given `frame` was not originally allocated by this `Allocator`.
-    unsafe fn dealloc(&mut self, frame: Self::Frame)  -> Result<(), AllocErr>;
+    unsafe fn dealloc(&mut self, frame: Self::Frame) -> Result<(), AllocErr>;
 
     // TODO: alloc_range/dealloc_range; requires an architecture-independent
     //       way of representing frame ranges.
-
 }

alarm_base/src/lend.rs

@@ -12,22 +12,20 @@
 //! or, "So You've Always Wished `*mut u8` Could `impl Drop`..."
 use alloc::allocator::{Alloc, AllocErr, Layout};
 use core::{mem, ops, ptr};
-
 use spin;
 
 /// An allocator that can provide borrowed handles.
 pub trait Lend {
-
     /// The type of the allocator providing the allocation.
     ///
     /// This has to be an associated type rather than `Self`
     /// so that `Lend` can be implemented for e.g. `Mutex<A>`.
     type Allocator: Alloc;
 
     /// Borrow an allocation for a `T` from this lender.
-    fn borrow<'a, T>(&'a self)
-                    -> Result<Borrowed<'a, T, Self::Allocator>, AllocErr>;
-
+    fn borrow<'a, T>(
+        &'a self,
+    ) -> Result<Borrowed<'a, T, Self::Allocator>, AllocErr>;
 }
 
 /// A borrowed handle on a heap allocation with a specified lifetime.
@@ -46,13 +44,11 @@ pub struct Borrowed<'alloc, T, A>
 where
     A: Alloc + 'alloc,
 {
-
     /// The allocated value this `Borrowed` handle owns.
     value: ptr::NonNull<T>,
 
     /// A reference to the allocator that provided us with T.
     allocator: &'alloc ::spin::Mutex<A>,
-
 }
 
 // ===== impl Lend =====
@@ -64,18 +60,17 @@ where
     type Allocator = A;
 
     /// Borrow an allocation for a `T` from this lender.
-    fn borrow<'a, T>(&'a self)
-                    -> Result<Borrowed<'a, T, Self::Allocator>, AllocErr> {
+    fn borrow<'a, T>(
+        &'a self,
+    ) -> Result<Borrowed<'a, T, Self::Allocator>, AllocErr> {
         let value = self.lock().alloc_one::<T>();
         value.map(|value| Borrowed {
             value,
             allocator: self,
         })
     }
-
 }
 
-
 // ===== impl Borrowed =====
 
 impl<'alloc, T, A> ops::Deref for Borrowed<'alloc, T, A>
@@ -85,7 +80,7 @@ where
     type Target = T;
 
     #[inline]
-    fn deref(&self) ->  &Self::Target {
+    fn deref(&self) -> &Self::Target {
         unsafe { self.value.as_ref() }
     }
 }
@@ -95,7 +90,7 @@ where
     A: Alloc + 'alloc,
 {
     #[inline]
-    fn deref_mut(&mut self) ->  &mut Self::Target {
+    fn deref_mut(&mut self) -> &mut Self::Target {
         unsafe { self.value.as_mut() }
     }
 }
@@ -106,16 +101,13 @@ where
 {
     fn drop(&mut self) {
         let address = self.value.as_ptr();
-        let layout = unsafe {
-            Layout::for_value(self.value.as_ref())
-        };
+        let layout = unsafe { Layout::for_value(self.value.as_ref()) };
         // ensure we drop the object _before_ deallocating it, so that
         // the object's `Drop` gets run first.
         mem::drop(address);
         unsafe {
             // lock the allocator and deallocate the object.
-            self.allocator.lock()
-                .dealloc(address as *mut _, layout)
+            self.allocator.lock().dealloc(address as *mut _, layout)
         }
     }
 }

alarm_base/src/lib.rs

@@ -5,9 +5,9 @@
 //  Copyright (c) 2018 Eliza Weisman
 //  Released under the terms of the MIT license. See `LICENSE` in the root
 //  directory of this repository for more information.
-// 
+//
 //! Base types for ALARM allocators
-//! 
+//!
 #![cfg_attr(not(feature = "std"), no_std)]
 #![deny(missing_docs)]
 #![feature(alloc, allocator_api)]

intruder_alarm/src/cursor.rs

@@ -9,7 +9,7 @@
 //
 //! Cursors allowing bi-directional traversal of data structures.
 //!
-use core::iter::{self, Iterator, DoubleEndedIterator};
+use core::iter::{self, DoubleEndedIterator, Iterator};
 
 //-----------------------------------------------------------------------------
 // Traits
@@ -47,23 +47,25 @@ pub trait Cursor {
     /// Return a reference to the next element from the cursor's position.
     fn peek_next(&self) -> Option<Self::Item>;
 
-    /// Return a reference to the previous element from the cursor's position.
+    /// Return a reference to the previous element from the cursor's
+    /// position.
     fn peek_back(&self) -> Option<Self::Item>;
 
-    /// Advance the cursor one element and return a reference to that element.
+    /// Advance the cursor one element and return a reference to that
+    /// element.
     #[inline]
     fn next_item(&mut self) -> Option<Self::Item> {
         self.move_forward();
         self.get()
     }
 
-    /// Move the cursor back one element and return a reference to that element.
+    /// Move the cursor back one element and return a reference to that
+    /// element.
     #[inline]
     fn prev_item(&mut self) -> Option<Self::Item> {
         self.move_back();
         self.get()
     }
-
 }
 
 /// A cursor that can mutate the parent data structure.
@@ -100,7 +102,6 @@ pub trait CursorMut<'a, T: 'a>: Cursor<Item = &'a mut T> {
     /// Insert the given item after the cursor's position.
     // TODO: ops::Place impl?
     fn insert_after(&mut self, item: T);
-
 }
 
 /// Conversion into a `Cursor``.
@@ -111,36 +112,32 @@ pub trait CursorMut<'a, T: 'a>: Cursor<Item = &'a mut T> {
 ///
 /// ...yes, it's just `IntoIterator` for `Cursor`s.
 pub trait IntoCursor {
-
     /// The type of the elements "under" the cursor.
     type Item;
 
     /// Which kind of cursor are we turning this into?
-    type IntoCursor: Cursor<Item=Self::Item>;
+    type IntoCursor: Cursor<Item = Self::Item>;
 
     /// Create a cursor from a value.
     fn into_iter(self) -> Self::IntoCursor;
-
 }
 
 // ===== impl Cursor =====
 
-impl<I> Iterator for Cursor<Item = I>{
+impl<I> Iterator for Cursor<Item = I> {
     type Item = I;
 
     #[inline]
     fn next(&mut self) -> Option<Self::Item> {
         self.next_item()
     }
-
 }
 
 impl<I> DoubleEndedIterator for Cursor<Item = I> {
     #[inline]
     fn next_back(&mut self) -> Option<Self::Item> {
         self.prev_item()
     }
-
 }
 
 // ===== impl IntoCursor =====
@@ -157,5 +154,3 @@ impl<I> DoubleEndedIterator for Cursor<Item = I> {
 //     }
 //
 // }
-
-

intruder_alarm/src/doubly/mod.rs

@@ -8,7 +8,6 @@
 //! like the allocator implementation itself, since each list element manages
 //! its own memory.
 use super::{Link, OwningRef, UnsafeRef};
-
 use core::iter::{Extend, FromIterator};
 use core::marker::PhantomData;
 use core::mem;
@@ -361,7 +360,7 @@ where
     #[inline]
     pub fn push_front<I>(&mut self, item: I) -> &mut Self
     where
-        I: Into<UnsafeRef<Node>>
+        I: Into<UnsafeRef<Node>>,
     {
         self.push_front_node(item.into())
     }
@@ -370,22 +369,17 @@ where
     #[inline]
     pub fn push_back<I>(&mut self, item: I) -> &mut Self
     where
-        I: Into<UnsafeRef<Node>>
+        I: Into<UnsafeRef<Node>>,
     {
         self.push_back_node(item.into())
     }
 }
 
-
-#[cfg(all(
-    feature = "alloc",
-    not(any(feature = "std", test))
-))]
+#[cfg(all(feature = "alloc", not(any(feature = "std", test))))]
 use alloc::boxed::Box;
 #[cfg(any(feature = "std", test))]
 use std::boxed::Box;
 
-
 #[cfg(any(feature = "alloc", feature = "std", test))]
 impl<T, Node> List<T, Node, Box<Node>>
 where
@@ -424,7 +418,6 @@ where
     }
 }
 
-
 #[cfg(any(feature = "alloc", feature = "std", test))]
 impl<T, Node> Extend<T> for List<T, Node, Box<Node>>
 where
@@ -453,7 +446,7 @@ where
 
 impl<T, Node, Ref, E> FromIterator<E> for List<T, Node, Ref>
 where
-    Self: Extend<E>
+    Self: Extend<E>,
 {
     #[inline]
     fn from_iter<I: IntoIterator<Item = E>>(iter: I) -> Self {

intruder_alarm/src/doubly/tests.rs

@@ -74,7 +74,6 @@ mod boxed {
 
     pub type NumberedList = List<usize, NumberedNode, Box<NumberedNode>>;
 
-
     mod push_node {
         use super::*;
         use std::boxed::Box;
@@ -436,19 +435,16 @@ mod boxed {
     }
 }
 
-
-
 mod unsafe_ref {
     use super::*;
     use UnsafeRef;
 
     pub type UnsafeList = List<usize, NumberedNode, UnsafeRef<NumberedNode>>;
 
-
     mod push_node {
         use super::*;
-        use std::boxed::Box;
         use UnsafeRef;
+        use std::boxed::Box;
 
         #[test]
         fn not_empty_after_first_push() {
@@ -818,7 +814,7 @@ mod unsafe_ref {
 
         let ext = vec![
             UnsafeRef::boxed(NumberedNode::from(3)),
-            UnsafeRef::boxed(NumberedNode::from(4))
+            UnsafeRef::boxed(NumberedNode::from(4)),
         ];
         list.extend(ext);
 
@@ -828,12 +824,13 @@ mod unsafe_ref {
 
     #[test]
     fn test_fromiter() {
-        let list_a = (0..10).into_iter()
+        let list_a = (0..10)
+            .into_iter()
             .map(|i| UnsafeRef::boxed(NumberedNode::from(i)));
         let mut nlist = UnsafeList::from_iter(list_a);
 
         for i in 0..10 {
             assert_eq!(nlist.pop_front_node().unwrap().number, i);
         }
     }
-}
+}