add option to deduplicate extern blocks

Author: pvdrz

src/lib.rs

@@ -592,6 +592,10 @@ impl Builder {
             output_vector.push("--sort-semantically".into());
         }
 
+        if self.options.deduplicate_extern_blocks {
+            output_vector.push("--deduplicate-extern-blocks".into());
+        }
+
         // Add clang arguments
 
         output_vector.push("--".into());
@@ -1481,14 +1485,20 @@ impl Builder {
         self
     }
 
-    /// If true, enables the sorting of the output in a predefined manner
+    /// If true, enables the sorting of the output in a predefined manner.
     ///
     /// TODO: Perhaps move the sorting order out into a config
     pub fn sort_semantically(mut self, doit: bool) -> Self {
         self.options.sort_semantically = doit;
         self
     }
 
+    /// If true, deduplicates extern blocks.
+    pub fn deduplicate_extern_blocks(mut self, doit: bool) -> Self {
+        self.options.deduplicate_extern_blocks = doit;
+        self
+    }
+
     /// Generate the Rust bindings using the options built up thus far.
     pub fn generate(mut self) -> Result<Bindings, BindgenError> {
         // Add any extra arguments from the environment to the clang command line.
@@ -2019,8 +2029,11 @@ struct BindgenOptions {
     /// Emit vtable functions.
     vtable_generation: bool,
 
-    /// Sort the code generation
+    /// Sort the code generation.
     sort_semantically: bool,
+
+    /// Deduplicate `extern` blocks.
+    deduplicate_extern_blocks: bool,
 }
 
 /// TODO(emilio): This is sort of a lie (see the error message that results from
@@ -2170,6 +2183,7 @@ impl Default for BindgenOptions {
             force_explicit_padding: false,
             vtable_generation: false,
             sort_semantically: false,
+            deduplicate_extern_blocks: false,
         }
     }
 }
@@ -2455,7 +2469,7 @@ impl Bindings {
 
         let (items, options, warnings) = codegen::codegen(context);
 
-        if options.sort_semantically {
+        if options.sort_semantically || options.deduplicate_extern_blocks {
             let module_wrapped_tokens =
                 quote!(mod wrapper_for_sorting_hack { #( #items )* });
 
@@ -2475,26 +2489,81 @@ impl Bindings {
                     .unwrap()
                     .1;
 
-            syn_parsed_items.sort_by_key(|item| match item {
-                syn::Item::Type(_) => 0,
-                syn::Item::Struct(_) => 1,
-                syn::Item::Const(_) => 2,
-                syn::Item::Fn(_) => 3,
-                syn::Item::Enum(_) => 4,
-                syn::Item::Union(_) => 5,
-                syn::Item::Static(_) => 6,
-                syn::Item::Trait(_) => 7,
-                syn::Item::TraitAlias(_) => 8,
-                syn::Item::Impl(_) => 9,
-                syn::Item::Mod(_) => 10,
-                syn::Item::Use(_) => 11,
-                syn::Item::Verbatim(_) => 12,
-                syn::Item::ExternCrate(_) => 13,
-                syn::Item::ForeignMod(_) => 14,
-                syn::Item::Macro(_) => 15,
-                syn::Item::Macro2(_) => 16,
-                _ => 18,
-            });
+            if options.deduplicate_extern_blocks {
+                // Here we will store all the items after deduplication.
+                let mut items = Vec::new();
+
+                // Keep all the extern blocks in a different `Vec` for faster search.
+                let mut foreign_mods = Vec::<syn::ItemForeignMod>::new();
+                for item in syn_parsed_items {
+                    match item {
+                        syn::Item::ForeignMod(syn::ItemForeignMod {
+                            attrs,
+                            abi,
+                            brace_token,
+                            items: foreign_items,
+                        }) => {
+                            let mut exists = false;
+                            for foreign_mod in &mut foreign_mods {
+                                // Check if there is a extern block with the same ABI and
+                                // attributes.
+                                if foreign_mod.attrs == attrs &&
+                                    foreign_mod.abi == abi
+                                {
+                                    // Merge the items of the two blocks.
+                                    foreign_mod
+                                        .items
+                                        .extend_from_slice(&foreign_items);
+                                    exists = true;
+                                    break;
+                                }
+                            }
+                            // If no existing extern block had the same ABI and attributes, store
+                            // it.
+                            if !exists {
+                                foreign_mods.push(syn::ItemForeignMod {
+                                    attrs,
+                                    abi,
+                                    brace_token,
+                                    items: foreign_items,
+                                });
+                            }
+                        }
+                        // If the item is not an extern block, we don't have to do anything.
+                        _ => items.push(item),
+                    }
+                }
+
+                // Move all the extern blocks alongiside the rest of the items.
+                for foreign_mod in foreign_mods {
+                    items.push(syn::Item::ForeignMod(foreign_mod));
+                }
+
+                syn_parsed_items = items;
+            }
+
+            if options.sort_semantically {
+                syn_parsed_items.sort_by_key(|item| match item {
+                    syn::Item::Type(_) => 0,
+                    syn::Item::Struct(_) => 1,
+                    syn::Item::Const(_) => 2,
+                    syn::Item::Fn(_) => 3,
+                    syn::Item::Enum(_) => 4,
+                    syn::Item::Union(_) => 5,
+                    syn::Item::Static(_) => 6,
+                    syn::Item::Trait(_) => 7,
+                    syn::Item::TraitAlias(_) => 8,
+                    syn::Item::Impl(_) => 9,
+                    syn::Item::Mod(_) => 10,
+                    syn::Item::Use(_) => 11,
+                    syn::Item::Verbatim(_) => 12,
+                    syn::Item::ExternCrate(_) => 13,
+                    syn::Item::ForeignMod(_) => 14,
+                    syn::Item::Macro(_) => 15,
+                    syn::Item::Macro2(_) => 16,
+                    _ => 18,
+                });
+            }
 
             let synful_items = syn_parsed_items
                 .into_iter()

src/options.rs

@@ -518,6 +518,9 @@ where
             Arg::new("sort-semantically")
                 .long("sort-semantically")
                 .help("Enables sorting of code generation in a predefined manner."),
+            Arg::new("deduplicate-extern-blocks")
+                .long("deduplicate-extern-blocks")
+                .help("Deduplicates extern blocks."),
             Arg::new("V")
                 .long("version")
                 .help("Prints the version, and exits"),
@@ -1007,5 +1010,9 @@ where
         builder = builder.sort_semantically(true);
     }
 
+    if matches.is_present("deduplicate-extern-blocks") {
+        builder = builder.deduplicate_extern_blocks(true);
+    }
+
     Ok((builder, output, verbose))
 }

tests/expectations/tests/deduplicate-extern-blocks.rs

@@ -0,0 +1,6 @@
+// bindgen-flags: --deduplicate-extern-blocks -- --target=x86_64-unknown-linux
+int foo();
+typedef struct Point {
+    int x;
+} Point;
+int bar();