Some cargo-fmt corrections.

src/bin/bindgen.rs

@@ -8,7 +8,7 @@ extern crate log;
 extern crate clang_sys;
 extern crate rustc_serialize;
 
-use bindgen::{BindgenOptions, Bindings, LinkType, ClangVersion, clang_version};
+use bindgen::{BindgenOptions, Bindings, ClangVersion, LinkType, clang_version};
 use std::default::Default;
 use std::env;
 use std::fs;
@@ -233,14 +233,20 @@ pub fn main() {
     let mut bind_args: Vec<_> = env::args().collect();
 
     let version = clang_version();
-    let expected_version = if cfg!(feature = "llvm_stable") { (3,8) } else { (3,9) };
+    let expected_version = if cfg!(feature = "llvm_stable") {
+        (3, 8)
+    } else {
+        (3, 9)
+    };
 
     info!("Clang Version: {}", version.full);
 
     match version.parsed {
         None => warn!("Couldn't parse libclang version"),
         Some(version) if version != expected_version => {
-            error!("Using clang {:?}, expected {:?}", version, expected_version);
+            error!("Using clang {:?}, expected {:?}",
+                   version,
+                   expected_version);
         }
         _ => {}
     }

src/clang.rs

@@ -285,7 +285,7 @@ impl Cursor {
     pub fn specialized(&self) -> Option<Cursor> {
         unsafe {
             let ret = Cursor {
-                x: clang_getSpecializedCursorTemplate(self.x)
+                x: clang_getSpecializedCursorTemplate(self.x),
             };
             if ret.is_valid() { Some(ret) } else { None }
         }

src/ir/item.rs

@@ -49,7 +49,9 @@ pub trait ItemCanonicalPath {
 /// up to (but not including) the implicit root module.
 pub trait ItemAncestors {
     /// Get an iterable over this item's ancestors.
-    fn ancestors<'a, 'b>(&self, ctx: &'a BindgenContext<'b>) -> ItemAncestorsIter<'a, 'b>;
+    fn ancestors<'a, 'b>(&self,
+                         ctx: &'a BindgenContext<'b>)
+                         -> ItemAncestorsIter<'a, 'b>;
 }
 
 /// An iterator over an item and its ancestors.

src/lib.rs

@@ -496,32 +496,37 @@ fn parse(context: &mut BindgenContext) {
 #[derive(Debug)]
 pub struct ClangVersion {
     /// Major and minor semvar, if parsing was successful
-    pub parsed: Option<(u32,u32)>,
+    pub parsed: Option<(u32, u32)>,
     /// full version string
     pub full: String,
 }
 
 /// Get the major and the minor semvar numbers of Clang's version
 pub fn clang_version() -> ClangVersion {
     let raw_v: String = clang::extract_clang_version();
-    let split_v: Option<Vec<&str>> = raw_v
-        .split_whitespace()
+    let split_v: Option<Vec<&str>> = raw_v.split_whitespace()
         .nth(2)
         .map(|v| v.split('.').collect());
     match split_v {
         Some(v) => {
             if v.len() >= 2 {
                 let maybe_major = v[0].parse::<u32>();
                 let maybe_minor = v[1].parse::<u32>();
-                match (maybe_major,maybe_minor) {
-                    (Ok(major),Ok(minor)) => return ClangVersion { parsed: Some((major,minor)), full: raw_v.clone() },
-                    _ => {},
+                match (maybe_major, maybe_minor) {
+                    (Ok(major), Ok(minor)) => {
+                        return ClangVersion {
+                            parsed: Some((major, minor)),
+                            full: raw_v.clone(),
+                        }
+                    }
+                    _ => {}
                 }
             }
-        },
-        None => {},
+        }
+        None => {}
     };
-    ClangVersion { parsed: None, full: raw_v.clone() }
+    ClangVersion {
+        parsed: None,
+        full: raw_v.clone(),
+    }
 }
-
-