workspace: reformat with latest cargo-fmt

Author: indygreg

binary-portability/src/elf.rs

@@ -9,9 +9,9 @@
 use {
     crate::{ObjectFileInfo, Result, UndefinedSymbol},
     object::{
+        Endianness, SectionIndex,
         elf::{DT_NEEDED, SHT_DYNSYM},
         read::elf::{Dyn, FileHeader, SectionHeader, Sym},
-        Endianness, SectionIndex,
     },
 };
 

llvm-option-parser/src/lib.rs

@@ -525,11 +525,12 @@ impl CommandOptions {
         I: Iterator<Item = T>,
         T: Into<OsString> + Clone,
     {
-        let arg = match args.next() { Some(arg) => {
-            arg.into()
-        } _ => {
-            return Ok(None);
-        }};
+        let arg = match args.next() {
+            Some(arg) => arg.into(),
+            _ => {
+                return Ok(None);
+            }
+        };
 
         // TODO expand response files, which have form `@path`.
         // Response files content is treated as regular command line parameters.
@@ -571,38 +572,44 @@ impl CommandOptions {
                 // Separate takes value from next argument.
                 OptionKind::Separate => {
                     if definition.matches_exact(&arg) {
-                        match args.next() { Some(value) => {
-                            let value = value.into();
-
-                            return Ok(Some(ParsedArgument::SingleValue(
-                                definition.clone(),
-                                value,
-                            )));
-                        } _ => {
-                            return Err(Error::ParseNoArgumentValue(
-                                definition.option_name.clone(),
-                            ));
-                        }}
-                    }
-                }
-                // Takes form `-name value` or `-namevalue`. e.g. `-l`.
-                OptionKind::JoinedOrSeparate => {
-                    if let Some(remaining) = definition.matches_prefix(&arg) {
-                        // Empty remaining means we consumed the full argument and the
-                        // value is the next argument.
-                        if remaining.is_empty() {
-                            match args.next() { Some(value) => {
+                        match args.next() {
+                            Some(value) => {
                                 let value = value.into();
 
                                 return Ok(Some(ParsedArgument::SingleValue(
                                     definition.clone(),
                                     value,
                                 )));
-                            } _ => {
+                            }
+                            _ => {
                                 return Err(Error::ParseNoArgumentValue(
                                     definition.option_name.clone(),
                                 ));
-                            }}
+                            }
+                        }
+                    }
+                }
+                // Takes form `-name value` or `-namevalue`. e.g. `-l`.
+                OptionKind::JoinedOrSeparate => {
+                    if let Some(remaining) = definition.matches_prefix(&arg) {
+                        // Empty remaining means we consumed the full argument and the
+                        // value is the next argument.
+                        if remaining.is_empty() {
+                            match args.next() {
+                                Some(value) => {
+                                    let value = value.into();
+
+                                    return Ok(Some(ParsedArgument::SingleValue(
+                                        definition.clone(),
+                                        value,
+                                    )));
+                                }
+                                _ => {
+                                    return Err(Error::ParseNoArgumentValue(
+                                        definition.option_name.clone(),
+                                    ));
+                                }
+                            }
                         } else {
                             return Ok(Some(ParsedArgument::SingleValue(
                                 definition.clone(),
@@ -615,19 +622,22 @@ impl CommandOptions {
                 // Takes form `-name=<key> value`.
                 OptionKind::JoinedAndSeparate => {
                     if let Some(remaining) = definition.matches_prefix(&arg) {
-                        match args.next() { Some(value) => {
-                            let value = value.into();
+                        match args.next() {
+                            Some(value) => {
+                                let value = value.into();
 
-                            return Ok(Some(ParsedArgument::SingleValueKeyed(
-                                definition.clone(),
-                                remaining.to_os_string(),
-                                value,
-                            )));
-                        } _ => {
-                            return Err(Error::ParseNoArgumentValue(
-                                definition.option_name.clone(),
-                            ));
-                        }}
+                                return Ok(Some(ParsedArgument::SingleValueKeyed(
+                                    definition.clone(),
+                                    remaining.to_os_string(),
+                                    value,
+                                )));
+                            }
+                            _ => {
+                                return Err(Error::ParseNoArgumentValue(
+                                    definition.option_name.clone(),
+                                ));
+                            }
+                        }
                     }
                 }
 
@@ -807,14 +817,13 @@ impl ParsedArguments {
                         match options
                             .iter_options()
                             .find(|candidate| &candidate.option_name == alias)
-                        { Some(canonical) => {
-                            Ok(arg.with_option(canonical.clone()))
-                        } _ => {
-                            Err(Error::AliasMissing(
+                        {
+                            Some(canonical) => Ok(arg.with_option(canonical.clone())),
+                            _ => Err(Error::AliasMissing(
                                 option.option_name.clone(),
                                 alias.to_string(),
-                            ))
-                        }}
+                            )),
+                        }
                     } else {
                         Ok(arg)
                     }