Rename `TypeKind::Named` to `TypeKind::TypeParam`

Also renames a bunch of other things referring to named types to refer to type
parameters.

Fixes #915

1 files changed, 87 insertions, 54 deletions

diff --git a/src/codegen/struct_layout.rs b/src/codegen/struct_layout.rs
index 2ba39bad..cd2d62f4 100644
--- a/src/codegen/struct_layout.rs
+++ b/src/codegen/struct_layout.rs
@@ -81,7 +81,11 @@ fn test_bytes_from_bits_pow2() {
 }
 
 impl<'a, 'ctx> StructLayoutTracker<'a, 'ctx> {
-    pub fn new(ctx: &'a BindgenContext<'ctx>, comp: &'a CompInfo, name: &'a str) -> Self {
+    pub fn new(
+        ctx: &'a BindgenContext<'ctx>,
+        comp: &'a CompInfo,
+        name: &'a str,
+    ) -> Self {
         StructLayoutTracker {
             name: name,
             ctx: ctx,
@@ -121,9 +125,11 @@ impl<'a, 'ctx> StructLayoutTracker<'a, 'ctx> {
 
         self.latest_offset += layout.size;
 
-        debug!("Offset: <bitfield>: {} -> {}",
-               self.latest_offset - layout.size,
-               self.latest_offset);
+        debug!(
+            "Offset: <bitfield>: {} -> {}",
+            self.latest_offset - layout.size,
+            self.latest_offset
+        );
 
         self.latest_field_layout = Some(layout);
         self.last_field_was_bitfield = true;
@@ -143,30 +149,33 @@ impl<'a, 'ctx> StructLayoutTracker<'a, 'ctx> {
 
     /// Add a padding field if necessary for a given new field _before_ adding
     /// that field.
-    pub fn pad_field(&mut self,
-                     field_name: &str,
-                     field_ty: &Type,
-                     field_offset: Option<usize>)
-                     -> Option<ast::StructField> {
+    pub fn pad_field(
+        &mut self,
+        field_name: &str,
+        field_ty: &Type,
+        field_offset: Option<usize>,
+    ) -> Option<ast::StructField> {
         let mut field_layout = match field_ty.layout(self.ctx) {
             Some(l) => l,
             None => return None,
         };
 
         if let TypeKind::Array(inner, len) =
-            *field_ty.canonical_type(self.ctx).kind() {
+            *field_ty.canonical_type(self.ctx).kind()
+        {
             // FIXME(emilio): As an _ultra_ hack, we correct the layout returned
             // by arrays of structs that have a bigger alignment than what we
             // can support.
             //
             // This means that the structs in the array are super-unsafe to
             // access, since they won't be properly aligned, but *shrug*.
-            if let Some(layout) = self.ctx
-                .resolve_type(inner)
-                .layout(self.ctx) {
+            if let Some(layout) = self.ctx.resolve_type(inner).layout(
+                self.ctx,
+            )
+            {
                 if layout.align > mem::size_of::<*mut ()>() {
                     field_layout.size = align_to(layout.size, layout.align) *
-                                        len;
+                        len;
                     field_layout.align = mem::size_of::<*mut ()>();
                 }
             }
@@ -187,25 +196,30 @@ impl<'a, 'ctx> StructLayoutTracker<'a, 'ctx> {
 
             // Otherwise the padding is useless.
             let need_padding = padding_bytes >= field_layout.align ||
-                               field_layout.align > mem::size_of::<*mut ()>();
+                field_layout.align > mem::size_of::<*mut ()>();
 
             self.latest_offset += padding_bytes;
 
-            debug!("Offset: <padding>: {} -> {}",
-                   self.latest_offset - padding_bytes,
-                   self.latest_offset);
-
-            debug!("align field {} to {}/{} with {} padding bytes {:?}",
-                   field_name,
-                   self.latest_offset,
-                   field_offset.unwrap_or(0) / 8,
-                   padding_bytes,
-                   field_layout);
+            debug!(
+                "Offset: <padding>: {} -> {}",
+                self.latest_offset - padding_bytes,
+                self.latest_offset
+            );
+
+            debug!(
+                "align field {} to {}/{} with {} padding bytes {:?}",
+                field_name,
+                self.latest_offset,
+                field_offset.unwrap_or(0) / 8,
+                padding_bytes,
+                field_layout
+            );
 
             if need_padding && padding_bytes != 0 {
-                Some(Layout::new(padding_bytes,
-                                 cmp::min(field_layout.align,
-                                          mem::size_of::<*mut ()>())))
+                Some(Layout::new(
+                    padding_bytes,
+                    cmp::min(field_layout.align, mem::size_of::<*mut ()>()),
+                ))
             } else {
                 None
             }
@@ -213,25 +227,33 @@ impl<'a, 'ctx> StructLayoutTracker<'a, 'ctx> {
 
         self.latest_offset += field_layout.size;
         self.latest_field_layout = Some(field_layout);
-        self.max_field_align = cmp::max(self.max_field_align,
-                                        field_layout.align);
+        self.max_field_align =
+            cmp::max(self.max_field_align, field_layout.align);
         self.last_field_was_bitfield = false;
 
-        debug!("Offset: {}: {} -> {}",
-               field_name,
-               self.latest_offset - field_layout.size,
-               self.latest_offset);
+        debug!(
+            "Offset: {}: {} -> {}",
+            field_name,
+            self.latest_offset - field_layout.size,
+            self.latest_offset
+        );
 
         padding_layout.map(|layout| self.padding_field(layout))
     }
 
     pub fn pad_struct(&mut self, layout: Layout) -> Option<ast::StructField> {
-        debug!("pad_struct:\n\tself = {:#?}\n\tlayout = {:#?}", self, layout);
+        debug!(
+            "pad_struct:\n\tself = {:#?}\n\tlayout = {:#?}",
+            self,
+            layout
+        );
 
         if layout.size < self.latest_offset {
-            error!("Calculated wrong layout for {}, too more {} bytes",
-                   self.name,
-                   self.latest_offset - layout.size);
+            error!(
+                "Calculated wrong layout for {}, too more {} bytes",
+                self.name,
+                self.latest_offset - layout.size
+            );
             return None;
         }
 
@@ -244,14 +266,17 @@ impl<'a, 'ctx> StructLayoutTracker<'a, 'ctx> {
         // regardless, because bitfields don't respect alignment as strictly as
         // other fields.
         if padding_bytes > 0 &&
-           (padding_bytes >= layout.align ||
-            (self.last_field_was_bitfield &&
-             padding_bytes >= self.latest_field_layout.unwrap().align) ||
-            layout.align > mem::size_of::<*mut ()>()) {
+            (padding_bytes >= layout.align ||
+                 (self.last_field_was_bitfield &&
+                      padding_bytes >=
+                          self.latest_field_layout.unwrap().align) ||
+                 layout.align > mem::size_of::<*mut ()>())
+        {
             let layout = if self.comp.packed() {
                 Layout::new(padding_bytes, 1)
             } else if self.last_field_was_bitfield ||
-                                   layout.align > mem::size_of::<*mut ()>() {
+                       layout.align > mem::size_of::<*mut ()>()
+            {
                 // We've already given up on alignment here.
                 Layout::for_size(padding_bytes)
             } else {
@@ -268,12 +293,15 @@ impl<'a, 'ctx> StructLayoutTracker<'a, 'ctx> {
 
     pub fn align_struct(&self, layout: Layout) -> Option<ast::StructField> {
         if self.max_field_align < layout.align &&
-           layout.align <= mem::size_of::<*mut ()>() {
+            layout.align <= mem::size_of::<*mut ()>()
+        {
             let ty = BlobTyBuilder::new(Layout::new(0, layout.align)).build();
 
-            Some(StructFieldBuilder::named("__bindgen_align")
-                .pub_()
-                .build_ty(ty))
+            Some(
+                StructFieldBuilder::named("__bindgen_align")
+                    .pub_()
+                    .build_ty(ty),
+            )
         } else {
             None
         }
@@ -293,7 +321,9 @@ impl<'a, 'ctx> StructLayoutTracker<'a, 'ctx> {
 
         self.max_field_align = cmp::max(self.max_field_align, layout.align);
 
-        StructFieldBuilder::named(padding_field_name).pub_().build_ty(ty)
+        StructFieldBuilder::named(padding_field_name)
+            .pub_()
+            .build_ty(ty)
     }
 
     /// Returns whether the new field is known to merge with a bitfield.
@@ -312,14 +342,17 @@ impl<'a, 'ctx> StructLayoutTracker<'a, 'ctx> {
 
         // If it was, we may or may not need to align, depending on what the
         // current field alignment and the bitfield size and alignment are.
-        debug!("align_to_bitfield? {}: {:?} {:?}",
-               self.last_field_was_bitfield,
-               layout,
-               new_field_layout);
+        debug!(
+            "align_to_bitfield? {}: {:?} {:?}",
+            self.last_field_was_bitfield,
+            layout,
+            new_field_layout
+        );
 
         if self.last_field_was_bitfield &&
-           new_field_layout.align <= layout.size % layout.align &&
-           new_field_layout.size <= layout.size % layout.align {
+            new_field_layout.align <= layout.size % layout.align &&
+            new_field_layout.size <= layout.size % layout.align
+        {
             // The new field will be coalesced into some of the remaining bits.
             //
             // FIXME(emilio): I think this may not catch everything?