Run `cargo fmt`

7 files changed, 48 insertions, 40 deletions

diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs
index 6f9291f7..b626fe34 100644
--- a/src/codegen/mod.rs
+++ b/src/codegen/mod.rs
@@ -12,7 +12,8 @@ use ir::derive::{CanDeriveCopy, CanDeriveDebug, CanDeriveDefault};
 use ir::enum_ty::{Enum, EnumVariant, EnumVariantValue};
 use ir::function::{Function, FunctionSig};
 use ir::int::IntKind;
-use ir::item::{Item, ItemSet, ItemAncestors, ItemCanonicalName, ItemCanonicalPath};
+use ir::item::{Item, ItemAncestors, ItemCanonicalName, ItemCanonicalPath,
+               ItemSet};
 use ir::item_kind::ItemKind;
 use ir::layout::Layout;
 use ir::module::Module;
@@ -2189,7 +2190,7 @@ impl ToRustTy for Type {
                         .map(|arg| arg.to_rust_ty(ctx))
                         .collect::<Vec<_>>();
 
-                    path.segments.last_mut().unwrap().parameters = if
+                    path.segments.last_mut().unwrap().parameters = if 
                         template_args.is_empty() {
                         None
                     } else {
diff --git a/src/ir/comp.rs b/src/ir/comp.rs
index ecc0442b..fff4655c 100644
--- a/src/ir/comp.rs
+++ b/src/ir/comp.rs
@@ -7,7 +7,6 @@ use super::item::Item;
 use super::layout::Layout;
 use super::traversal::{EdgeKind, Trace, Tracer};
 use super::ty::{TemplateDeclaration, Type};
-use super::traversal::Trace;
 use clang;
 use parse::{ClangItemParser, ParseError};
 use std::cell::Cell;
@@ -1079,11 +1078,8 @@ impl<'a> CanDeriveCopy<'a> for CompInfo {
 impl Trace for CompInfo {
     type Extra = Item;
 
-    fn trace<T>(&self,
-                context: &BindgenContext,
-                tracer: &mut T,
-                item: &Item)
-        where T: Tracer
+    fn trace<T>(&self, context: &BindgenContext, tracer: &mut T, item: &Item)
+        where T: Tracer,
     {
         // TODO: We should properly distinguish template instantiations from
         // template declarations at the type level. Why are some template
diff --git a/src/ir/context.rs b/src/ir/context.rs
index 63d451a8..d2fb2bef 100644
--- a/src/ir/context.rs
+++ b/src/ir/context.rs
@@ -2,7 +2,7 @@
 
 use super::derive::{CanDeriveCopy, CanDeriveDebug, CanDeriveDefault};
 use super::int::IntKind;
-use super::item::{Item, ItemSet, ItemCanonicalPath};
+use super::item::{Item, ItemCanonicalPath, ItemSet};
 use super::item_kind::ItemKind;
 use super::module::{Module, ModuleKind};
 use super::traversal::{self, Edge, ItemTraversal};
@@ -152,8 +152,11 @@ pub struct BindgenContext<'ctx> {
 }
 
 /// A traversal of whitelisted items.
-pub type WhitelistedItems<'ctx, 'gen> =
-    ItemTraversal<'ctx, 'gen, ItemSet, Vec<ItemId>, fn(Edge) -> bool>;
+pub type WhitelistedItems<'ctx, 'gen> = ItemTraversal<'ctx,
+                                                      'gen,
+                                                      ItemSet,
+                                                      Vec<ItemId>,
+                                                      fn(Edge) -> bool>;
 
 impl<'ctx> BindgenContext<'ctx> {
     /// Construct the context for the given `options`.
@@ -547,7 +550,9 @@ impl<'ctx> BindgenContext<'ctx> {
         assert!(self.current_module == self.root_module);
 
         let roots = self.items().map(|(&id, _)| id);
-        traversal::AssertNoDanglingItemsTraversal::new(self, roots, traversal::all_edges)
+        traversal::AssertNoDanglingItemsTraversal::new(self,
+                                                       roots,
+                                                       traversal::all_edges)
     }
 
     // This deserves a comment. Builtin types don't get a valid declaration, so
diff --git a/src/ir/function.rs b/src/ir/function.rs
index cd504b9c..22b9c9b0 100644
--- a/src/ir/function.rs
+++ b/src/ir/function.rs
@@ -4,7 +4,6 @@ use super::context::{BindgenContext, ItemId};
 use super::item::Item;
 use super::traversal::{Trace, Tracer};
 use super::ty::TypeKind;
-use super::traversal::Trace;
 use clang;
 use clang_sys::CXCallingConv;
 use parse::{ClangItemParser, ClangSubItemParser, ParseError, ParseResult};
@@ -320,11 +319,8 @@ impl ClangSubItemParser for Function {
 impl Trace for FunctionSig {
     type Extra = ();
 
-    fn trace<T>(&self,
-                _: &BindgenContext,
-                tracer: &mut T,
-                _: &())
-        where T: Tracer
+    fn trace<T>(&self, _: &BindgenContext, tracer: &mut T, _: &())
+        where T: Tracer,
     {
         tracer.visit(self.return_type());
 
diff --git a/src/ir/item.rs b/src/ir/item.rs
index f168579e..4c65c433 100644
--- a/src/ir/item.rs
+++ b/src/ir/item.rs
@@ -8,7 +8,6 @@ use super::item_kind::ItemKind;
 use super::module::Module;
 use super::traversal::{Trace, Tracer};
 use super::ty::{TemplateDeclaration, Type, TypeKind};
-use super::traversal::Trace;
 use clang;
 use clang_sys;
 use parse::{ClangItemParser, ClangSubItemParser, ParseError, ParseResult};
@@ -172,7 +171,7 @@ impl Trace for ItemId {
     type Extra = ();
 
     fn trace<T>(&self, ctx: &BindgenContext, tracer: &mut T, extra: &())
-        where T: Tracer
+        where T: Tracer,
     {
         ctx.resolve_item(*self).trace(ctx, tracer, extra);
     }
@@ -182,7 +181,7 @@ impl Trace for Item {
     type Extra = ();
 
     fn trace<T>(&self, ctx: &BindgenContext, tracer: &mut T, _extra: &())
-        where T: Tracer
+        where T: Tracer,
     {
         if self.is_hidden(ctx) {
             return;
diff --git a/src/ir/traversal.rs b/src/ir/traversal.rs
index 4e78ce2a..eb4fc686 100644
--- a/src/ir/traversal.rs
+++ b/src/ir/traversal.rs
@@ -1,8 +1,8 @@
 //! Traversal of the graph of IR items and types.
 
-use std::collections::{BTreeMap, VecDeque};
 use super::context::{BindgenContext, ItemId};
 use super::item::ItemSet;
+use std::collections::{BTreeMap, VecDeque};
 
 /// An outgoing edge in the IR graph is a reference from some item to another
 /// item:
@@ -14,7 +14,7 @@ use super::item::ItemSet;
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct Edge {
     to: ItemId,
-    kind: EdgeKind
+    kind: EdgeKind,
 }
 
 impl Edge {
@@ -119,18 +119,20 @@ impl<'ctx, 'gen> TraversalStorage<'ctx, 'gen> for ItemSet {
 /// each item. This is useful for providing debug assertions with meaningful
 /// diagnostic messages about dangling items.
 #[derive(Debug)]
-pub struct Paths<'ctx, 'gen>(BTreeMap<ItemId, ItemId>, &'ctx BindgenContext<'gen>)
+pub struct Paths<'ctx, 'gen>(BTreeMap<ItemId, ItemId>,
+                             &'ctx BindgenContext<'gen>)
     where 'gen: 'ctx;
 
 impl<'ctx, 'gen> TraversalStorage<'ctx, 'gen> for Paths<'ctx, 'gen>
-    where 'gen: 'ctx
+    where 'gen: 'ctx,
 {
     fn new(ctx: &'ctx BindgenContext<'gen>) -> Self {
         Paths(BTreeMap::new(), ctx)
     }
 
     fn add(&mut self, from: Option<ItemId>, item: ItemId) -> bool {
-        let newly_discovered = self.0.insert(item, from.unwrap_or(item)).is_none();
+        let newly_discovered =
+            self.0.insert(item, from.unwrap_or(item)).is_none();
 
         if self.1.resolve_item_fallible(item).is_none() {
             let mut path = vec![];
@@ -241,7 +243,11 @@ pub struct ItemTraversal<'ctx, 'gen, Storage, Queue, Predicate>
     currently_traversing: Option<ItemId>,
 }
 
-impl<'ctx, 'gen, Storage, Queue, Predicate> ItemTraversal<'ctx, 'gen, Storage, Queue, Predicate>
+impl<'ctx, 'gen, Storage, Queue, Predicate> ItemTraversal<'ctx,
+                                                          'gen,
+                                                          Storage,
+                                                          Queue,
+                                                          Predicate>
     where 'gen: 'ctx,
           Storage: TraversalStorage<'ctx, 'gen>,
           Queue: TraversalQueue,
@@ -272,7 +278,8 @@ impl<'ctx, 'gen, Storage, Queue, Predicate> ItemTraversal<'ctx, 'gen, Storage, Q
     }
 }
 
-impl<'ctx, 'gen, Storage, Queue, Predicate> Tracer for ItemTraversal<'ctx, 'gen, Storage, Queue, Predicate>
+impl<'ctx, 'gen, Storage, Queue, Predicate> Tracer
+    for ItemTraversal<'ctx, 'gen, Storage, Queue, Predicate>
     where 'gen: 'ctx,
           Storage: TraversalStorage<'ctx, 'gen>,
           Queue: TraversalQueue,
@@ -283,15 +290,17 @@ impl<'ctx, 'gen, Storage, Queue, Predicate> Tracer for ItemTraversal<'ctx, 'gen,
         if !self.predicate.should_follow(edge) {
             return;
         }
-               
-        let is_newly_discovered = self.seen.add(self.currently_traversing, item);
+
+        let is_newly_discovered = self.seen
+            .add(self.currently_traversing, item);
         if is_newly_discovered {
             self.queue.push(item)
         }
     }
 }
 
-impl<'ctx, 'gen, Storage, Queue, Predicate> Iterator for ItemTraversal<'ctx, 'gen, Storage, Queue, Predicate>
+impl<'ctx, 'gen, Storage, Queue, Predicate> Iterator
+    for ItemTraversal<'ctx, 'gen, Storage, Queue, Predicate>
     where 'gen: 'ctx,
           Storage: TraversalStorage<'ctx, 'gen>,
           Queue: TraversalQueue,
@@ -324,7 +333,11 @@ impl<'ctx, 'gen, Storage, Queue, Predicate> Iterator for ItemTraversal<'ctx, 'ge
 /// See `BindgenContext::assert_no_dangling_item_traversal` for more
 /// information.
 pub type AssertNoDanglingItemsTraversal<'ctx, 'gen> =
-    ItemTraversal<'ctx, 'gen, Paths<'ctx, 'gen>, VecDeque<ItemId>, fn(Edge) -> bool>;
+    ItemTraversal<'ctx,
+                  'gen,
+                  Paths<'ctx, 'gen>,
+                  VecDeque<ItemId>,
+                  fn(Edge) -> bool>;
 
 #[cfg(test)]
 mod tests {
diff --git a/src/ir/ty.rs b/src/ir/ty.rs
index 236eae8b..ec168f02 100644
--- a/src/ir/ty.rs
+++ b/src/ir/ty.rs
@@ -1026,7 +1026,9 @@ impl Type {
             CXType_MemberPointer |
             CXType_Pointer => {
                 let inner = Item::from_ty_or_ref(ty.pointee_type().unwrap(),
-                                                 location, None, ctx);
+                                                 location,
+                                                 None,
+                                                 ctx);
                 TypeKind::Pointer(inner)
             }
             CXType_BlockPointer => TypeKind::BlockPointer,
@@ -1067,8 +1069,7 @@ impl Type {
             }
             CXType_Typedef => {
                 let inner = cursor.typedef_type().expect("Not valid Type?");
-                let inner =
-                    Item::from_ty_or_ref(inner, location, None, ctx);
+                let inner = Item::from_ty_or_ref(inner, location, None, ctx);
                 TypeKind::Alias(inner)
             }
             CXType_Enum => {
@@ -1128,11 +1129,8 @@ impl Type {
 impl Trace for Type {
     type Extra = Item;
 
-    fn trace<T>(&self,
-                context: &BindgenContext,
-                tracer: &mut T,
-                item: &Item)
-        where T: Tracer
+    fn trace<T>(&self, context: &BindgenContext, tracer: &mut T, item: &Item)
+        where T: Tracer,
     {
         match *self.kind() {
             TypeKind::Pointer(inner) |