Do not evaluate variadic template types

This is a workaround for an internal clang assertion that gets triggered
if we try to evaluate a variadic template type reference.

Fixes #283

Author: fitzgen

libbindgen/src/clang.rs

@@ -477,7 +477,7 @@ impl Cursor {
     }
 
     /// Try to evaluate this cursor.
-    pub fn evaluate(&self) -> EvalResult {
+    pub fn evaluate(&self) -> Option<EvalResult> {
         EvalResult::new(*self)
     }
 }
@@ -1296,10 +1296,33 @@ impl EvalResult {
 #[cfg(not(feature = "llvm_stable"))]
 impl EvalResult {
     /// Evaluate `cursor` and return the result.
-    pub fn new(cursor: Cursor) -> Self {
-        EvalResult {
-            x: unsafe { clang_Cursor_Evaluate(cursor.x) },
+    pub fn new(cursor: Cursor) -> Option<Self> {
+        ast_dump(&cursor, 0);
+
+        // Clang has an internal assertion we can trigger if we try to evaluate
+        // a cursor containing a variadic template type reference. Triggering
+        // the assertion aborts the process, and we don't want that. Clang
+        // *also* doesn't expose any API for finding variadic vs non-variadic
+        // template type references, let alone whether a type referenced is a
+        // template type, instead they seem to show up as type references to an
+        // unexposed type. Our solution is to just flat out ban all
+        // `CXType_Unexposed` from evaluation.
+        let mut found_cant_eval = false;
+        cursor.visit(|c| {
+            if c.kind() == CXCursor_TypeRef && c.cur_type().kind() == CXType_Unexposed {
+                found_cant_eval = true;
+                CXChildVisit_Break
+            } else {
+                CXChildVisit_Recurse
+            }
+        });
+        if found_cant_eval {
+            return None;
         }
+
+        Some(EvalResult {
+            x: unsafe { clang_Cursor_Evaluate(cursor.x) },
+        })
     }
 
     fn kind(&self) -> Enum_CXEvalResultKind {

libbindgen/src/ir/var.rs

@@ -205,11 +205,12 @@ impl ClangSubItemParser for Var {
                 // to look at the canonical type of the pointee too, and check
                 // is char, u8, or i8 I guess).
                 let value = if is_bool {
-                    cursor.evaluate().as_int()
+                    cursor.evaluate()
+                        .and_then(|v| v.as_int())
                         .map(|val| VarType::Bool(val != 0))
                 } else if is_integer {
                     cursor.evaluate()
-                        .as_int()
+                        .and_then(|v| v.as_int())
                         .map(|val| val as i64)
                         .or_else(|| {
                             let tu = ctx.translation_unit();
@@ -218,7 +219,7 @@ impl ClangSubItemParser for Var {
                         .map(VarType::Int)
                 } else if is_float {
                     cursor.evaluate()
-                        .as_double()
+                        .and_then(|v| v.as_double())
                         .map(VarType::Float)
                 } else {
                     None

libbindgen/tests/expectations/tests/eval-variadic-template-parameter.rs

@@ -0,0 +1,12 @@
+/* automatically generated by rust-bindgen */
+
+
+#![allow(non_snake_case)]
+
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct B<T> {
+    pub _address: u8,
+    pub _phantom_0: ::std::marker::PhantomData<T>,
+}

libbindgen/tests/headers/eval-variadic-template-parameter.hpp

@@ -0,0 +1,8 @@
+// bindgen-flags: -- -std=c++11
+
+template <typename... T>
+struct B {
+    // Can't generate anything meaningful in Rust for this, but we shouldn't
+    // trigger an assertion inside Clang.
+    static const long c = sizeof...(T);
+};