Do not print builtin macro definitions in ast_dump

Resolves issue rust-lang#476. Moves out logic for checking whether a cursor
has a filename (previously used exclusively in private function lib::filter_builtins) into the actual cursor. This code is then used to check whether a cursor is a builtin when dumping the AST.

Author: Tai Sassen-Liang

src/clang.rs

@@ -76,6 +76,12 @@ impl Cursor {
         }
     }
 
+    /// Returns whether the cursor refers to a built-in definition.
+    pub fn is_builtin(&self) -> bool {
+        let (file, _, _, _) = self.location().location();
+        !file.name().is_some()
+    }
+
     /// Get the `Cursor` for this cursor's referent's lexical parent.
     ///
     /// The lexical parent is the parent of the definition. The semantic parent
@@ -1415,6 +1421,9 @@ pub fn ast_dump(c: &Cursor, depth: isize) -> CXChildVisitResult {
     }
 
     fn print_cursor<S: AsRef<str>>(depth: isize, prefix: S, c: &Cursor) {
+        if c.is_builtin() {
+            return;
+        }
         let prefix = prefix.as_ref();
         print_indent(depth,
                      format!(" {}kind = {}", prefix, kind_to_str(c.kind())));

src/lib.rs

@@ -826,12 +826,7 @@ impl<'ctx> Bindings<'ctx> {
 /// Determines whether the given cursor is in any of the files matched by the
 /// options.
 fn filter_builtins(ctx: &BindgenContext, cursor: &clang::Cursor) -> bool {
-    let (file, _, _, _) = cursor.location().location();
-
-    match file.name() {
-        None => ctx.options().builtins,
-        Some(..) => true,
-    }
+    !cursor.is_builtin() || ctx.options().builtins
 }
 
 /// Parse one `Item` from the Clang cursor.

tests/expectations/tests/auto.rs

@@ -9,7 +9,10 @@
 pub struct Foo {
     pub _address: u8,
 }
-pub const Foo_kFoo: bool = true;
+extern "C" {
+    #[link_name = "_ZN3Foo4kFooE"]
+    pub static Foo_kFoo: bool;
+}
 #[test]
 fn bindgen_test_layout_Foo() {
     assert_eq!(::std::mem::size_of::<Foo>() , 1usize , concat ! (

tests/expectations/tests/const_bool.rs

@@ -4,13 +4,19 @@
 #![allow(non_snake_case)]
 
 
-pub const k: bool = true;
+extern "C" {
+    #[link_name = "_ZL1k"]
+    pub static k: bool;
+}
 #[repr(C)]
 #[derive(Debug, Default, Copy)]
 pub struct A {
     pub _address: u8,
 }
-pub const A_k: bool = false;
+extern "C" {
+    #[link_name = "_ZN1A1kE"]
+    pub static A_k: bool;
+}
 #[test]
 fn bindgen_test_layout_A() {
     assert_eq!(::std::mem::size_of::<A>() , 1usize , concat ! (
@@ -22,4 +28,7 @@ impl Clone for A {
     fn clone(&self) -> Self { *self }
 }
 pub type foo = bool;
-pub const k2: foo = true;
+extern "C" {
+    #[link_name = "_ZL2k2"]
+    pub static k2: foo;
+}

tests/expectations/tests/constant-evaluate.rs

@@ -11,10 +11,31 @@ pub const bar: _bindgen_ty_1 = _bindgen_ty_1::bar;
 pub enum _bindgen_ty_1 { foo = 4, bar = 8, }
 pub type EasyToOverflow = ::std::os::raw::c_ulonglong;
 pub const k: EasyToOverflow = 2147483648;
-pub const k_expr: EasyToOverflow = 0;
-pub const BAZ: ::std::os::raw::c_longlong = 24;
-pub const fuzz: f64 = 51.;
-pub const BAZZ: ::std::os::raw::c_schar = 53;
-pub const WAT: ::std::os::raw::c_schar = 0;
-pub const bytestring: &'static [u8; 4usize] = b"Foo\x00";
-pub const NOT_UTF8: [u8; 5usize] = [240, 40, 140, 40, 0];
+extern "C" {
+    #[link_name = "k_expr"]
+    pub static k_expr: EasyToOverflow;
+}
+extern "C" {
+    #[link_name = "BAZ"]
+    pub static BAZ: ::std::os::raw::c_longlong;
+}
+extern "C" {
+    #[link_name = "fuzz"]
+    pub static fuzz: f64;
+}
+extern "C" {
+    #[link_name = "BAZZ"]
+    pub static BAZZ: ::std::os::raw::c_char;
+}
+extern "C" {
+    #[link_name = "WAT"]
+    pub static WAT: ::std::os::raw::c_char;
+}
+extern "C" {
+    #[link_name = "bytestring"]
+    pub static mut bytestring: *const ::std::os::raw::c_char;
+}
+extern "C" {
+    #[link_name = "NOT_UTF8"]
+    pub static mut NOT_UTF8: *const ::std::os::raw::c_char;
+}