add --unsafe-blocks option

Author: pvdrz

Cargo.toml

@@ -57,7 +57,7 @@ lazycell = "1"
 lazy_static = "1"
 peeking_take_while = "0.1.2"
 quote = { version = "1", default-features = false }
-syn = { version = "1.0.99", features = ["full", "extra-traits"]}
+syn = { version = "1.0.99", features = ["full", "extra-traits", "visit-mut"]}
 regex = { version = "1.5", default-features = false , features = ["std", "unicode"] }
 which = { version = "4.2.1", optional = true, default-features = false }
 shlex = "1"

src/lib.rs

@@ -619,6 +619,10 @@ impl Builder {
             output_vector.push("--merge-extern-blocks".into());
         }
 
+        if self.options.unsafe_blocks {
+            output_vector.push("--unsafe-blocks".into());
+        }
+
         // Add clang arguments
 
         output_vector.push("--".into());
@@ -1560,6 +1564,12 @@ impl Builder {
         self
     }
 
+    /// If true, wraps all the bodies of generated `unsafe` functions in `unsafe` blocks.
+    pub fn unsafe_blocks(mut self, doit: bool) -> Self {
+        self.options.unsafe_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.
@@ -2110,6 +2120,9 @@ struct BindgenOptions {
 
     /// Deduplicate `extern` blocks.
     merge_extern_blocks: bool,
+
+    /// Wrap the bodies of `unsafe` functions in `unsafe` blocks
+    unsafe_blocks: bool,
 }
 
 /// TODO(emilio): This is sort of a lie (see the error message that results from
@@ -2120,7 +2133,7 @@ impl ::std::panic::UnwindSafe for BindgenOptions {}
 impl BindgenOptions {
     /// Whether any of the enabled options requires `syn`.
     fn require_syn(&self) -> bool {
-        self.sort_semantically || self.merge_extern_blocks
+        self.sort_semantically || self.merge_extern_blocks || self.unsafe_blocks
     }
 
     fn build(&mut self) {
@@ -2272,6 +2285,7 @@ impl Default for BindgenOptions {
             vtable_generation: false,
             sort_semantically: false,
             merge_extern_blocks: false,
+            unsafe_blocks: Default::default(),
         }
     }
 }
@@ -2653,6 +2667,71 @@ impl Bindings {
                 });
             }
 
+            if options.unsafe_blocks {
+                struct UnsafeBlocksVisitor;
+
+                impl UnsafeBlocksVisitor {
+                    fn add_unsafe_block(
+                        &self,
+                        sig: &syn::Signature,
+                        block: &mut syn::Block,
+                    ) {
+                        if sig.unsafety.is_some() {
+                            let inner_block = std::mem::replace(
+                                block,
+                                syn::Block {
+                                    brace_token: Default::default(),
+                                    stmts: Default::default(),
+                                },
+                            );
+
+                            block.stmts.push(syn::Stmt::Expr(
+                                syn::Expr::Unsafe(syn::ExprUnsafe {
+                                    attrs: Default::default(),
+                                    block: inner_block,
+                                    unsafe_token: Default::default(),
+                                }),
+                            ));
+                        }
+                    }
+                }
+
+                impl syn::visit_mut::VisitMut for UnsafeBlocksVisitor {
+                    fn visit_item_fn_mut(&mut self, item: &mut syn::ItemFn) {
+                        self.add_unsafe_block(&item.sig, &mut item.block);
+
+                        syn::visit_mut::visit_item_fn_mut(self, item)
+                    }
+
+                    fn visit_impl_item_method_mut(
+                        &mut self,
+                        item: &mut syn::ImplItemMethod,
+                    ) {
+                        self.add_unsafe_block(&item.sig, &mut item.block);
+
+                        syn::visit_mut::visit_impl_item_method_mut(self, item)
+                    }
+
+                    fn visit_trait_item_method_mut(
+                        &mut self,
+                        item: &mut syn::TraitItemMethod,
+                    ) {
+                        if let Some(ref mut block) = item.default {
+                            self.add_unsafe_block(&item.sig, block);
+                        }
+
+                        syn::visit_mut::visit_trait_item_method_mut(self, item)
+                    }
+                }
+
+                for item in &mut syn_parsed_items {
+                    syn::visit_mut::visit_item_mut(
+                        &mut UnsafeBlocksVisitor,
+                        item,
+                    );
+                }
+            }
+
             let synful_items = syn_parsed_items
                 .into_iter()
                 .map(|item| item.into_token_stream());

src/options.rs

@@ -563,6 +563,9 @@ where
             Arg::new("merge-extern-blocks")
                 .long("merge-extern-blocks")
                 .help("Deduplicates extern blocks."),
+            Arg::new("unsafe-blocks")
+                .long("unsafe-blocks")
+                .help("Wrap all the bodies of generated `unsafe` functions in `unsafe` blocks."),
             Arg::new("V")
                 .long("version")
                 .help("Prints the version, and exits"),
@@ -1083,5 +1086,9 @@ where
         builder = builder.merge_extern_blocks(true);
     }
 
+    if matches.is_present("unsafe-blocks") {
+        builder = builder.unsafe_blocks(true);
+    }
+
     Ok((builder, output, verbose))
 }

tests/expectations/tests/unsafe_blocks.rs

@@ -0,0 +1,5 @@
+// bindgen-flags: --dynamic-loading TestLib --unsafe-blocks
+
+int foo(int x, int y);
+int bar(void *x);
+int baz();