Use rustfmt

src/bindgen/bindings.rs

@@ -2,10 +2,10 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use std::io::{Read, Write};
+use std::fs;
 use std::fs::File;
+use std::io::{Read, Write};
 use std::path;
-use std::fs;
 
 use bindgen::config::{Config, Language};
 use bindgen::ir::{Constant, Function, ItemContainer, Static};

src/bindgen/builder.rs

@@ -4,11 +4,11 @@
 
 use std::path;
 
+use bindgen::bindings::Bindings;
 use bindgen::cargo::Cargo;
 use bindgen::config::{Braces, Config, Language};
 use bindgen::error::Error;
 use bindgen::library::Library;
-use bindgen::bindings::Bindings;
 use bindgen::parser::{self, Parse};
 
 /// A builder for generating a bindings header.
@@ -266,10 +266,16 @@ impl Builder {
                     None,
                     Some(&binding_lib_name),
                     self.config.parse.parse_deps,
-                    self.config.parse.clean
+                    self.config.parse.clean,
                 )?
             } else {
-                Cargo::load(&lib_dir, None, None, self.config.parse.parse_deps, self.config.parse.clean)?
+                Cargo::load(
+                    &lib_dir,
+                    None,
+                    None,
+                    self.config.parse.parse_deps,
+                    self.config.parse.clean,
+                )?
             };
 
             result.extend_with(&parser::parse_lib(

src/bindgen/cargo/cargo.rs

@@ -31,7 +31,7 @@ pub(crate) struct Cargo {
 
     lock: Option<Lock>,
     metadata: Metadata,
-    clean: bool
+    clean: bool,
 }
 
 impl Cargo {
@@ -43,12 +43,12 @@ impl Cargo {
         lock_file: Option<&str>,
         binding_crate_name: Option<&str>,
         use_cargo_lock: bool,
-        clean: bool
+        clean: bool,
     ) -> Result<Cargo, Error> {
         let toml_path = crate_dir.join("Cargo.toml");
         let lock_path = match lock_file {
             Some(v) => PathBuf::from(v),
-            None => crate_dir.join("Cargo.lock")
+            None => crate_dir.join("Cargo.lock"),
         };
 
         let lock = if use_cargo_lock {
@@ -77,7 +77,7 @@ impl Cargo {
             binding_crate_name: binding_crate_name,
             lock: lock,
             metadata: metadata,
-            clean: clean
+            clean: clean,
         })
     }
 
@@ -198,6 +198,11 @@ impl Cargo {
     }
 
     pub(crate) fn expand_crate(&self, package: &PackageRef) -> Result<String, cargo_expand::Error> {
-        cargo_expand::expand(&self.manifest_path, &package.name, &package.version, self.clean)
+        cargo_expand::expand(
+            &self.manifest_path,
+            &package.name,
+            &package.version,
+            self.clean,
+        )
     }
 }

src/bindgen/cargo/cargo_expand.rs

@@ -6,7 +6,7 @@ use std::env;
 use std::io;
 use std::path::Path;
 use std::process::Command;
-use std::str::{Utf8Error, from_utf8};
+use std::str::{from_utf8, Utf8Error};
 
 extern crate tempdir;
 use self::tempdir::TempDir;
@@ -35,7 +35,12 @@ impl From<Utf8Error> for Error {
 
 /// Use rustc to expand and pretty print the crate into a single file,
 /// removing any macros in the process.
-pub fn expand(manifest_path: &Path, crate_name: &str, version: &str, use_tempdir: bool) -> Result<String, Error> {
+pub fn expand(
+    manifest_path: &Path,
+    crate_name: &str,
+    version: &str,
+    use_tempdir: bool,
+) -> Result<String, Error> {
     let cargo = env::var("CARGO").unwrap_or_else(|_| String::from("cargo"));
     let mut cmd = Command::new(cargo);
 

src/bindgen/cargo/cargo_lock.rs

@@ -2,9 +2,9 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+use std::fs::File;
 use std::io;
 use std::io::Read;
-use std::fs::File;
 use std::path::Path;
 
 use toml;

src/bindgen/cargo/cargo_metadata.rs

@@ -11,10 +11,10 @@
 
 use std::collections::HashMap;
 use std::env;
-use std::process::Command;
-use std::str::{Utf8Error, from_utf8};
 use std::io;
 use std::path::Path;
+use std::process::Command;
+use std::str::{from_utf8, Utf8Error};
 
 use serde_json;
 

src/bindgen/cargo/cargo_toml.rs

@@ -2,9 +2,9 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+use std::fs::File;
 use std::io;
 use std::io::Read;
-use std::fs::File;
 use std::path::Path;
 
 use toml;

src/bindgen/cdecl.rs

@@ -72,23 +72,43 @@ impl CDecl {
         match t {
             &Type::Path(ref path) => {
                 if is_const {
-                    assert!(self.type_qualifers.len() == 0, "error generating cdecl for {:?}", t);
+                    assert!(
+                        self.type_qualifers.len() == 0,
+                        "error generating cdecl for {:?}",
+                        t
+                    );
                     self.type_qualifers = "const".to_owned();
                 }
 
-                assert!(self.type_name.len() == 0, "error generating cdecl for {:?}", t);
+                assert!(
+                    self.type_name.len() == 0,
+                    "error generating cdecl for {:?}",
+                    t
+                );
                 self.type_name = path.name.clone();
-                assert!(self.type_generic_args.len() == 0, "error generating cdecl for {:?}", t);
+                assert!(
+                    self.type_generic_args.len() == 0,
+                    "error generating cdecl for {:?}",
+                    t
+                );
                 self.type_generic_args = path.generics.clone();
                 self.type_ctype = path.ctype;
             }
             &Type::Primitive(ref p) => {
                 if is_const {
-                    assert!(self.type_qualifers.len() == 0, "error generating cdecl for {:?}", t);
+                    assert!(
+                        self.type_qualifers.len() == 0,
+                        "error generating cdecl for {:?}",
+                        t
+                    );
                     self.type_qualifers = "const".to_owned();
                 }
 
-                assert!(self.type_name.len() == 0, "error generating cdecl for {:?}", t);
+                assert!(
+                    self.type_name.len() == 0,
+                    "error generating cdecl for {:?}",
+                    t
+                );
                 self.type_name = p.to_string();
             }
 

src/bindgen/config.rs

@@ -2,8 +2,8 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use std::default::Default;
 use std::collections::HashMap;
+use std::default::Default;
 use std::fs::File;
 use std::io::prelude::*;
 use std::io::{self, BufReader};
@@ -128,8 +128,8 @@ impl FromStr for Style {
         match s {
             "Both" => Ok(Style::Both),
             "both" => Ok(Style::Both),
-            "Tag" =>  Ok(Style::Tag),
-            "tag" =>  Ok(Style::Tag),
+            "Tag" => Ok(Style::Tag),
+            "tag" => Ok(Style::Tag),
             "Type" => Ok(Style::Type),
             "type" => Ok(Style::Type),
             _ => Err(format!("Unrecognized Style: '{}'.", s)),
@@ -391,7 +391,7 @@ pub struct ParseConfig {
     pub expand: Vec<String>,
     /// Whether to use a new temporary target directory when running `rustc --pretty=expanded`.
     /// This may be required for some build processes.
-    pub clean: bool
+    pub clean: bool,
 }
 
 impl Default for ParseConfig {

src/bindgen/dependencies.rs

@@ -2,8 +2,8 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use std::collections::HashSet;
 use std::cmp::Ordering;
+use std::collections::HashSet;
 
 use bindgen::ir::{ItemContainer, Path};
 

src/bindgen/error.rs

@@ -4,10 +4,10 @@
 
 use std::fmt;
 
-pub use syn::synom::ParseError;
+pub use bindgen::cargo::cargo_expand::Error as CargoExpandError;
 pub use bindgen::cargo::cargo_metadata::Error as CargoMetadataError;
 pub use bindgen::cargo::cargo_toml::Error as CargoTomlError;
-pub use bindgen::cargo::cargo_expand::Error as CargoExpandError;
+pub use syn::synom::ParseError;
 
 #[derive(Debug)]
 pub enum Error {

src/bindgen/ir/cfg.rs

@@ -111,9 +111,7 @@ impl Cfg {
                 ref lit,
                 ..
             })) => match lit {
-                &syn::Lit::Str(ref value) => {
-                    Some(Cfg::Named(format!("{}", ident), value.value()))
-                }
+                &syn::Lit::Str(ref value) => Some(Cfg::Named(format!("{}", ident), value.value())),
                 _ => None,
             },
             &syn::NestedMeta::Meta(syn::Meta::List(syn::MetaList {
@@ -146,7 +144,7 @@ impl Cfg {
                 } else {
                     None
                 }
-            },
+            }
             _ => None,
         }
     }

src/bindgen/ir/constant.rs

@@ -8,8 +8,8 @@ use std::mem;
 use syn;
 
 use bindgen::config::{Config, Language};
-use bindgen::ir::{AnnotationSet, Cfg, CfgWrite, Documentation, Item, ItemContainer, Type};
 use bindgen::declarationtyperesolver::DeclarationTypeResolver;
+use bindgen::ir::{AnnotationSet, Cfg, CfgWrite, Documentation, Item, ItemContainer, Type};
 use bindgen::writer::{Source, SourceWriter};
 
 #[derive(Debug, Clone)]

src/bindgen/ir/enumeration.rs

@@ -9,9 +9,9 @@ use syn;
 use bindgen::config::{Config, Language};
 use bindgen::declarationtyperesolver::DeclarationTypeResolver;
 use bindgen::dependencies::Dependencies;
-use bindgen::library::Library;
 use bindgen::ir::{AnnotationSet, Cfg, CfgWrite, Documentation, GenericParams, GenericPath, Item,
                   ItemContainer, Repr, ReprStyle, ReprType, Struct, Type};
+use bindgen::library::Library;
 use bindgen::rename::{IdentifierType, RenameRule};
 use bindgen::utilities::find_first_some;
 use bindgen::writer::{ListType, Source, SourceWriter};
@@ -107,8 +107,10 @@ impl EnumVariant {
             discriminant,
             body: body.map(|body| {
                 (
-                    RenameRule::SnakeCase
-                        .apply_to_pascal_case(&format!("{}", variant.ident), IdentifierType::StructMember),
+                    RenameRule::SnakeCase.apply_to_pascal_case(
+                        &format!("{}", variant.ident),
+                        IdentifierType::StructMember,
+                    ),
                     body,
                 )
             }),
@@ -320,7 +322,6 @@ impl Source for Enum {
         let is_tagged = self.tag.is_some();
         let separate_tag = self.repr.style == ReprStyle::C;
 
-
         // If tagged, we need to emit a proper struct/union wrapper around our enum
         if is_tagged && config.language == Language::Cxx {
             out.write(if separate_tag { "struct " } else { "union " });
@@ -334,7 +335,6 @@ impl Source for Enum {
             &self.name
         };
 
-
         // Emit the actual enum
         if config.language == Language::C {
             if size.is_none() && config.style.generate_typedef() {
@@ -381,7 +381,6 @@ impl Source for Enum {
         }
         // Done emitting the enum
 
-
         // If tagged, we need to emit structs for the cases and union them together
         if is_tagged {
             // Emit the cases for the structs
@@ -397,7 +396,6 @@ impl Source for Enum {
             out.new_line();
             out.new_line();
 
-
             // Emit the actual union
             if config.language == Language::C {
                 if config.style.generate_typedef() {
@@ -458,11 +456,10 @@ impl Source for Enum {
                 out.close_brace(true);
             }
 
-
             // Emit convenience methods
-            if config.language == Language::Cxx &&
-               config.enumeration.derive_helper_methods(&self.annotations) {
-
+            if config.language == Language::Cxx
+                && config.enumeration.derive_helper_methods(&self.annotations)
+            {
                 for variant in &self.variants {
                     out.new_line();
                     out.new_line();
@@ -482,8 +479,9 @@ impl Source for Enum {
 
                     if let Some((_, ref body)) = variant.body {
                         out.write_vertical_source_list(
-                            &body
-                                .fields.iter().skip(skip_fields)
+                            &body.fields
+                                .iter()
+                                .skip(skip_fields)
                                 .map(|&(ref name, ref ty, _)| {
                                     // const-ref args to constructor
                                     (format!("const& {}", arg_renamer(name)), ty.clone())
@@ -501,8 +499,13 @@ impl Source for Enum {
                     if let Some((ref variant_name, ref body)) = variant.body {
                         for &(ref field_name, ..) in body.fields.iter().skip(skip_fields) {
                             out.new_line();
-                            write!(out, "result.{}.{} = {};",
-                                variant_name, field_name, arg_renamer(field_name));
+                            write!(
+                                out,
+                                "result.{}.{} = {};",
+                                variant_name,
+                                field_name,
+                                arg_renamer(field_name)
+                            );
                         }
                     }
 

src/bindgen/ir/generics.rs

@@ -1,5 +1,5 @@
-use std::ops::Deref;
 use std::io::Write;
+use std::ops::Deref;
 
 use syn;