Do a cargo fmt pass

Author: HadrienG2

src/error/mod.rs

@@ -33,16 +33,17 @@ impl<T> Completion<T> {
             Completion::Warning(res, stat) => {
                 warn!("Encountered UEFI warning: {:?}", stat);
                 res
-            },
+            }
         }
     }
 
     /// Assume that no warning occured, panic if not
     pub fn unwrap(self) -> T {
         match self {
             Completion::Success(res) => res,
-            Completion::Warning(_, w) =>
-                unwrap_failed("Called `Completion::unwrap()` on a `Warning` value", w),
+            Completion::Warning(_, w) => {
+                unwrap_failed("Called `Completion::unwrap()` on a `Warning` value", w)
+            }
         }
     }
 

src/proto/console/text/input.rs

@@ -35,7 +35,7 @@ impl Input {
 
         match (self.read_key_stroke)(self, &mut key) {
             Status::NOT_READY => Ok(None.into()),
-            other => other.into_with(|| Some(key))
+            other => other.into_with(|| Some(key)),
         }
     }
 

src/proto/console/text/output.rs

@@ -159,8 +159,9 @@ impl fmt::Write for Output {
             i += 1;
 
             if i == BUF_SIZE {
-                flush_buffer(&mut buf, &mut i).map_err(|_| ucs2::Error::BufferOverflow)
-                                              .map(|completion| completion.value())
+                flush_buffer(&mut buf, &mut i)
+                    .map_err(|_| ucs2::Error::BufferOverflow)
+                    .map(|completion| completion.value())
             } else {
                 Ok(())
             }

src/table/boot.rs

@@ -180,7 +180,8 @@ impl BootServices {
             &mut map_key,
             &mut entry_size,
             &mut entry_version,
-        ).into_with(move || {
+        )
+        .into_with(move || {
             let len = map_size / entry_size;
             let iter = MemoryMapIter {
                 buffer,

uefi-exts/src/boot.rs

@@ -20,8 +20,7 @@ impl BootServicesExt for BootServices {
         let search_type = SearchType::from_proto::<P>();
 
         // Determine how much we need to allocate.
-        let (buffer_size, warn1) = self.locate_handle(search_type, None)?
-                                       .split();
+        let (buffer_size, warn1) = self.locate_handle(search_type, None)?.split();
 
         // Allocate a large enough buffer.
         let mut buffer = Vec::with_capacity(buffer_size);
@@ -31,22 +30,24 @@ impl BootServicesExt for BootServices {
         }
 
         // Perform the search.
-        let (buffer_size, warn2) = self.locate_handle(search_type, Some(&mut buffer))?
-                                       .split();
+        let (buffer_size, warn2) = self.locate_handle(search_type, Some(&mut buffer))?.split();
 
         // Once the vector has been filled, update its size.
         unsafe {
             buffer.set_len(buffer_size);
         }
 
-        warn1.into_with(|| buffer).map(|completion| completion.with_warning(warn2))
+        warn1
+            .into_with(|| buffer)
+            .map(|completion| completion.with_warning(warn2))
     }
 
     fn find_protocol<P: Protocol>(&self) -> Option<NonNull<P>> {
         // Retrieve all handles implementing this.
         self.find_handles::<P>()
             // Convert to an option.
-            .ok()?.value()
+            .ok()?
+            .value()
             // Using the `find_handles` function might not return _only_ compatible protocols.
             // We have to retrieve them all and find one that works.
             .iter()