add --unsafe-blocks option

Author: pvdrz

bindgen-cli/options.rs

@@ -574,6 +574,9 @@ where
                 .value_name("override")
                 .multiple_occurrences(true)
                 .number_of_values(1),
+            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"),
@@ -1106,5 +1109,9 @@ where
         }
     }
 
+    if matches.is_present("unsafe-blocks") {
+        builder = builder.unsafe_blocks(true);
+    }
+
     Ok((builder, output, verbose))
 }

bindgen-tests/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();

bindgen-tests/tests/headers/unsafe_blocks.h

@@ -6,9 +6,11 @@ use crate::BindgenOptions;
 
 mod merge_extern_blocks;
 mod sort_semantically;
+mod unsafe_blocks;
 
 use merge_extern_blocks::merge_extern_blocks;
 use sort_semantically::sort_semantically;
+use unsafe_blocks::unsafe_blocks;
 
 struct PostProcessingPass {
     should_run: fn(&BindgenOptions) -> bool,
@@ -26,8 +28,11 @@ macro_rules! pass {
     };
 }
 
-const PASSES: &[PostProcessingPass] =
-    &[pass!(merge_extern_blocks), pass!(sort_semantically)];
+const PASSES: &[PostProcessingPass] = &[
+    pass!(merge_extern_blocks),
+    pass!(sort_semantically),
+    pass!(unsafe_blocks),
+];
 
 pub(crate) fn postprocessing(
     items: Vec<TokenStream>,

bindgen/codegen/postprocessing/mod.rs

@@ -0,0 +1,60 @@
+use syn::{
+    visit_mut::{
+        visit_impl_item_method_mut, visit_item_fn_mut,
+        visit_trait_item_method_mut, VisitMut,
+    },
+    ExprUnsafe, ImplItemMethod, ItemFn, ItemMod, Stmt, TraitItemMethod,
+};
+
+pub(crate) fn unsafe_blocks(item_mod: &mut ItemMod) {
+    Visitor.visit_item_mod_mut(item_mod)
+}
+
+struct Visitor;
+
+impl Visitor {
+    fn add_unsafe_block(&self, sig: &syn::Signature, block: &mut syn::Block) {
+        if sig.unsafety.is_none() {
+            return;
+        }
+
+        let inner_block = std::mem::replace(
+            block,
+            syn::Block {
+                brace_token: Default::default(),
+                stmts: Default::default(),
+            },
+        );
+
+        block.stmts.push(Stmt::Expr(
+            ExprUnsafe {
+                attrs: Default::default(),
+                block: inner_block,
+                unsafe_token: Default::default(),
+            }
+            .into(),
+        ));
+    }
+}
+
+impl VisitMut for Visitor {
+    fn visit_impl_item_method_mut(&mut self, item: &mut ImplItemMethod) {
+        self.add_unsafe_block(&item.sig, &mut item.block);
+
+        visit_impl_item_method_mut(self, item)
+    }
+
+    fn visit_item_fn_mut(&mut self, item: &mut ItemFn) {
+        self.add_unsafe_block(&item.sig, &mut item.block);
+
+        visit_item_fn_mut(self, item)
+    }
+
+    fn visit_trait_item_method_mut(&mut self, item: &mut TraitItemMethod) {
+        if let Some(ref mut block) = item.default {
+            self.add_unsafe_block(&item.sig, block);
+        }
+
+        visit_trait_item_method_mut(self, item)
+    }
+}

bindgen/codegen/postprocessing/unsafe_blocks.rs

@@ -624,6 +624,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());
@@ -1566,6 +1570,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(self) -> Result<Bindings, BindgenError> {
         let mut options = self.options.clone();
@@ -2129,6 +2139,9 @@ struct BindgenOptions {
     merge_extern_blocks: bool,
 
     abi_overrides: HashMap<Abi, RegexSet>,
+
+    /// Wrap the bodies of `unsafe` functions in `unsafe` blocks
+    unsafe_blocks: bool,
 }
 
 impl BindgenOptions {
@@ -2301,6 +2314,7 @@ impl Default for BindgenOptions {
             sort_semantically: false,
             merge_extern_blocks: false,
             abi_overrides: Default::default(),
+            unsafe_blocks: Default::default(),
         }
     }
 }