style: Update bindgen to 0.31.2.

components/style/Cargo.toml

@@ -79,7 +79,7 @@ kernel32-sys = "0.2"
 [build-dependencies]
 lazy_static = "0.2"
 log = "0.3"
-bindgen = { version = "0.29.1", optional = true }
+bindgen = { version = "0.31.2", optional = true }
 regex = {version = "0.2", optional = true}
 walkdir = "1.0"
 toml = {version = "0.2.1", optional = true, default-features = false}

components/style/build_gecko.rs

@@ -200,7 +200,13 @@ mod bindings {
 
     impl BuilderExt for Builder {
         fn get_initial_builder() -> Builder {
-            let mut builder = Builder::default();
+            use bindgen::RustTarget;
+
+            // Disable rust unions, because we replace some types inside of
+            // them.
+            let mut builder = Builder::default()
+                .rustfmt_bindings(false)
+                .rust_target(RustTarget::Stable_1_0);
             for dir in SEARCH_PATHS.iter() {
                 builder = builder.clang_arg("-I").clang_arg(dir.to_str().unwrap());
             }
@@ -233,24 +239,24 @@ mod bindings {
         // https://github.com/nikomatsakis/rust-memory-model/issues/2
         fn zero_size_type(self, ty: &str, structs_list: &HashSet<&str>) -> Builder {
             if !structs_list.contains(ty) {
-                self.hide_type(ty)
+                self.blacklist_type(ty)
                     .raw_line(format!("enum {}Void {{ }}", ty))
                     .raw_line(format!("pub struct {0}({0}Void);", ty))
             } else {
                 self
             }
         }
         fn borrowed_type(self, ty: &str) -> Builder {
-            self.hide_type(format!("{}Borrowed", ty))
+            self.blacklist_type(format!("{}Borrowed", ty))
                 .raw_line(format!("pub type {0}Borrowed<'a> = &'a {0};", ty))
-                .hide_type(format!("{}BorrowedOrNull", ty))
+                .blacklist_type(format!("{}BorrowedOrNull", ty))
                 .raw_line(format!("pub type {0}BorrowedOrNull<'a> = Option<&'a {0}>;", ty))
         }
         fn mutable_borrowed_type(self, ty: &str) -> Builder {
             self.borrowed_type(ty)
-                .hide_type(format!("{}BorrowedMut", ty))
+                .blacklist_type(format!("{}BorrowedMut", ty))
                 .raw_line(format!("pub type {0}BorrowedMut<'a> = &'a mut {0};", ty))
-                .hide_type(format!("{}BorrowedMutOrNull", ty))
+                .blacklist_type(format!("{}BorrowedMutOrNull", ty))
                 .raw_line(format!("pub type {0}BorrowedMutOrNull<'a> = Option<&'a mut {0}>;", ty))
         }
     }
@@ -342,7 +348,7 @@ mod bindings {
         fn handle_common(self, fixups: &mut Vec<Fixup>) -> BuilderWithConfig<'a> {
             self.handle_str_items("headers", |b, item| b.header(add_include(item)))
                 .handle_str_items("raw-lines", |b, item| b.raw_line(item))
-                .handle_str_items("hide-types", |b, item| b.hide_type(item))
+                .handle_str_items("hide-types", |b, item| b.blacklist_type(item))
                 .handle_table_items("fixups", |builder, item| {
                     fixups.push(Fixup {
                         pat: item["pat"].as_str().unwrap().into(),
@@ -391,9 +397,9 @@ mod bindings {
         let builder = BuilderWithConfig::new(builder, CONFIG["structs"].as_table().unwrap())
             .handle_common(&mut fixups)
             .handle_str_items("bitfield-enums", |b, item| b.bitfield_enum(item))
-            .handle_str_items("constified-enums", |b, item| b.constified_enum(item))
-            .handle_str_items("whitelist-vars", |b, item| b.whitelisted_var(item))
-            .handle_str_items("whitelist-types", |b, item| b.whitelisted_type(item))
+            .handle_str_items("rusty-enums", |b, item| b.rustified_enum(item))
+            .handle_str_items("whitelist-vars", |b, item| b.whitelist_var(item))
+            .handle_str_items("whitelist-types", |b, item| b.whitelist_type(item))
             .handle_str_items("opaque-types", |b, item| b.opaque_type(item))
             .handle_list("constified-enum-variants", |builder, iter| {
                 let mut map = HashMap::new();
@@ -411,11 +417,16 @@ mod bindings {
                 let gecko = item["gecko"].as_str().unwrap();
                 let servo = item["servo"].as_str().unwrap();
                 let gecko_name = gecko.rsplit("::").next().unwrap();
+                let gecko = gecko.split("::")
+                                .map(|s| format!("\\s*{}\\s*", s))
+                                .collect::<Vec<_>>()
+                                .join("::");
+
                 fixups.push(Fixup {
-                    pat: format!("\\broot::{}\\b", gecko),
+                    pat: format!("\\broot\\s*::\\s*{}\\b", gecko),
                     rep: format!("::gecko_bindings::structs::{}", gecko_name)
                 });
-                builder.hide_type(gecko)
+                builder.blacklist_type(gecko)
                     .raw_line(format!("pub type {0}{2} = {1}{2};", gecko_name, servo,
                                       if generic { "<T>" } else { "" }))
             })
@@ -480,9 +491,9 @@ mod bindings {
         let mut fixups = vec![];
         let mut builder = BuilderWithConfig::new(builder, config)
             .handle_common(&mut fixups)
-            .handle_str_items("whitelist-functions", |b, item| b.whitelisted_function(item))
+            .handle_str_items("whitelist-functions", |b, item| b.whitelist_function(item))
             .handle_str_items("structs-types", |mut builder, ty| {
-                builder = builder.hide_type(ty)
+                builder = builder.blacklist_type(ty)
                     .raw_line(format!("use gecko_bindings::structs::{};", ty));
                 structs_types.insert(ty);
                 // TODO this is hacky, figure out a better way to do it without
@@ -500,16 +511,16 @@ mod bindings {
             .handle_table_items("array-types", |builder, item| {
                 let cpp_type = item["cpp-type"].as_str().unwrap();
                 let rust_type = item["rust-type"].as_str().unwrap();
-                builder.hide_type(format!("nsTArrayBorrowed_{}", cpp_type))
+                builder
                     .raw_line(format!(concat!("pub type nsTArrayBorrowed_{}<'a> = ",
                                               "&'a mut ::gecko_bindings::structs::nsTArray<{}>;"),
                                       cpp_type, rust_type))
             })
             .handle_table_items("servo-owned-types", |mut builder, item| {
                 let name = item["name"].as_str().unwrap();
-                builder = builder.hide_type(format!("{}Owned", name))
+                builder = builder.blacklist_type(format!("{}Owned", name))
                     .raw_line(format!("pub type {0}Owned = ::gecko_bindings::sugar::ownership::Owned<{0}>;", name))
-                    .hide_type(format!("{}OwnedOrNull", name))
+                    .blacklist_type(format!("{}OwnedOrNull", name))
                     .raw_line(format!(concat!("pub type {0}OwnedOrNull = ",
                                               "::gecko_bindings::sugar::ownership::OwnedOrNull<{0}>;"), name))
                     .mutable_borrowed_type(name);
@@ -527,7 +538,7 @@ mod bindings {
             .get_builder();
         for ty in get_arc_types().iter() {
             builder = builder
-                .hide_type(format!("{}Strong", ty))
+                .blacklist_type(format!("{}Strong", ty))
                 .raw_line(format!("pub type {0}Strong = ::gecko_bindings::sugar::ownership::Strong<{0}>;", ty))
                 .borrowed_type(ty)
                 .zero_size_type(ty, &structs_types);