Implement CanDeriveDebug for TemplateInstantiation

We need the template instantiation's layout to determine if we can derive debug
for it when the instantiation's template definition has non-type parameters.

Author: fitzgen

src/ir/comp.rs

@@ -864,7 +864,7 @@ impl CanDeriveDefault for CompInfo {
 
             return layout.unwrap_or_else(Layout::zero)
                 .opaque()
-                .can_derive_debug(ctx, ());
+                .can_derive_default(ctx, ());
         }
 
         self.detect_derive_default_cycle.set(true);

src/ir/template.rs

@@ -30,7 +30,8 @@
 use clang;
 use parse::ClangItemParser;
 use super::context::{BindgenContext, ItemId};
-use super::derive::CanDeriveCopy;
+use super::derive::{CanDeriveCopy, CanDeriveDebug};
+use super::layout::Layout;
 use super::item::Item;
 use super::traversal::{EdgeKind, Trace, Tracer};
 
@@ -148,6 +149,33 @@ impl<'a> CanDeriveCopy<'a> for TemplateInstantiation {
     }
 }
 
+impl CanDeriveDebug for TemplateInstantiation {
+    type Extra = Option<Layout>;
+
+    fn can_derive_debug(&self,
+                        ctx: &BindgenContext,
+                        layout: Option<Layout>)
+                        -> bool {
+        self.args.iter().all(|arg| arg.can_derive_debug(ctx, ())) &&
+            ctx.resolve_type(self.definition)
+                .as_comp()
+                .and_then(|c| {
+                    // For non-type template parameters, we generate an opaque
+                    // blob, and in this case the instantiation has a better
+                    // idea of the layout than the definition does.
+                    if c.has_non_type_template_params() {
+                        let opaque = layout.unwrap_or(Layout::zero()).opaque();
+                        Some(opaque.can_derive_debug(ctx, ()))
+                    } else {
+                        None
+                    }
+                })
+                .unwrap_or_else(|| {
+                    self.definition.can_derive_debug(ctx, ())
+                })
+    }
+}
+
 impl Trace for TemplateInstantiation {
     type Extra = ();
 

src/ir/ty.rs

@@ -636,6 +636,9 @@ impl CanDeriveDebug for Type {
             TypeKind::Comp(ref info) => {
                 info.can_derive_debug(ctx, self.layout(ctx))
             }
+            TypeKind::TemplateInstantiation(ref inst) => {
+                inst.can_derive_debug(ctx, self.layout(ctx))
+            }
             _ => true,
         }
     }