Make all extern "C" functions unsafe

rust-lang/rust#23452 makes safe functions no longer a subtype of unsafe
functions. For consistency, change the definitions of `raw::lua_Reader`,
`raw::lua_Writer`, and `raw::lua_Alloc` to be `unsafe` and update all
places where we provide these functions. Also update the `lua_extern!`
and `lua_extern_pub!` macros to produce `unsafe` functions.

Author: lilyball

src/lib.rs

@@ -308,22 +308,18 @@ impl State {
             }
         };
 
-        extern "C" fn alloc(_ud: *mut libc::c_void, ptr: *mut libc::c_void, _osize: libc::size_t,
-                            nsize: libc::size_t) -> *mut libc::c_void {
-            unsafe {
-                if nsize == 0 {
-                    libc::free(ptr as *mut libc::c_void);
-                    ptr::null_mut()
-                } else {
-                    libc::realloc(ptr, nsize)
-                }
+        unsafe extern "C" fn alloc(_ud: *mut libc::c_void, ptr: *mut libc::c_void,
+                                   _osize: libc::size_t, nsize: libc::size_t) -> *mut libc::c_void {
+            if nsize == 0 {
+                libc::free(ptr as *mut libc::c_void);
+                ptr::null_mut()
+            } else {
+                libc::realloc(ptr, nsize)
             }
         }
-        extern "C" fn panic(L: *mut raw::lua_State) -> c_int {
-            unsafe {
-                let s = RawState::from_lua_State(L).describe_(-1, false);
-                panic!("unprotected error in call to Lua API ({})", s);
-            }
+        unsafe extern "C" fn panic(L: *mut raw::lua_State) -> c_int {
+            let s = RawState::from_lua_State(L).describe_(-1, false);
+            panic!("unprotected error in call to Lua API ({})", s);
         }
     }
 }

src/macro.rs

@@ -4,11 +4,9 @@
 macro_rules! lua_extern {
     ($(unsafe fn $name:ident($arg:ident: &mut $typ:ty) -> i32 $code:block)+) => (
         $(
-            extern "C" fn $name($arg: *mut ::lua::raw::lua_State) -> ::libc::c_int {
-                unsafe {
-                    let mut $arg = ::lua::ExternState::from_lua_State($arg);
-                    return inner(&mut $arg) as ::libc::c_int;
-                }
+            unsafe extern "C" fn $name($arg: *mut ::lua::raw::lua_State) -> ::libc::c_int {
+                let mut $arg = ::lua::ExternState::from_lua_State($arg);
+                return inner(&mut $arg) as ::libc::c_int;
 
                 unsafe fn inner($arg: &mut $typ) -> i32 $code
             }
@@ -20,11 +18,9 @@ macro_rules! lua_extern {
 macro_rules! lua_extern_pub {
     ($(unsafe fn $name:ident($arg:ident: &mut $typ:ty) -> i32 $code:block)+) => (
         $(
-            pub extern "C" fn $name($arg: *mut ::lua::raw::lua_State) -> ::libc::c_int {
-                unsafe {
-                    let mut $arg = ::lua::ExternState::from_lua_State($arg);
-                    return inner(&mut $arg) as ::libc::c_int;
-                }
+            pub unsafe extern "C" fn $name($arg: *mut ::lua::raw::lua_State) -> ::libc::c_int {
+                let mut $arg = ::lua::ExternState::from_lua_State($arg);
+                return inner(&mut $arg) as ::libc::c_int;
 
                 unsafe fn inner($arg: &mut $typ) -> i32 $code
             }

src/raw.rs

@@ -46,15 +46,16 @@ pub type lua_State = libc::c_void;
 pub type lua_CFunction = unsafe extern "C" fn(L: *mut lua_State) -> c_int;
 
 /// Function type for reading blocks when loading Lua chunks.
-pub type lua_Reader = extern "C" fn(L: *mut lua_State, ud: *mut libc::c_void,
-                                    sz: *mut libc::size_t) -> *const libc::c_char;
+pub type lua_Reader = unsafe extern "C" fn(L: *mut lua_State, ud: *mut libc::c_void,
+                                           sz: *mut libc::size_t) -> *const libc::c_char;
 /// Function type for writing blocks when dumping Lua chunks.
-pub type lua_Writer = extern "C" fn(L: *mut lua_State, p: *const libc::c_void, sz: libc::size_t,
-                                    ud: *mut libc::c_void) -> libc::c_int;
+pub type lua_Writer = unsafe extern "C" fn(L: *mut lua_State, p: *const libc::c_void, sz: libc::size_t,
+                                           ud: *mut libc::c_void) -> libc::c_int;
 
 /// Prototype for memory-allocation functions
-pub type lua_Alloc = extern "C" fn(ud: *mut libc::c_void, ptr: *mut libc::c_void,
-                                osize: libc::size_t, nsize: libc::size_t) -> *mut libc::c_void;
+pub type lua_Alloc = unsafe extern "C" fn(ud: *mut libc::c_void, ptr: *mut libc::c_void,
+                                          osize: libc::size_t, nsize: libc::size_t)
+                                         -> *mut libc::c_void;
 
 // lua_State manipulation
 extern {

src/rawtests.rs

@@ -6,20 +6,18 @@ use aux;
 
 // implement the same function that luaL_newstate uses, so we can test lua_newstate directly
 // FIXME (#10025): We can't define this as `unsafe extern "C"`
-extern "C" fn alloc_helper(_ud: *mut libc::c_void, ptr: *mut libc::c_void, _osize: libc::size_t,
-                         nsize: libc::size_t) -> *mut libc::c_void {
-    unsafe {
-        if nsize == 0 {
-            libc::free(ptr as *mut libc::c_void);
-            ptr::null_mut()
-        } else {
-            libc::realloc(ptr, nsize)
-        }
+unsafe extern "C" fn alloc_helper(_ud: *mut libc::c_void, ptr: *mut libc::c_void,
+                                  _osize: libc::size_t, nsize: libc::size_t) -> *mut libc::c_void {
+    if nsize == 0 {
+        libc::free(ptr as *mut libc::c_void);
+        ptr::null_mut()
+    } else {
+        libc::realloc(ptr, nsize)
     }
 }
 
 // panic function should panic!() so Lua doesn't abort
-extern "C" fn panic_helper(_L: *mut raw::lua_State) -> libc::c_int {
+unsafe extern "C" fn panic_helper(_L: *mut raw::lua_State) -> libc::c_int {
     panic!("lua error");
 }
 

src/tests.rs

@@ -56,7 +56,7 @@ fn test_describe() {
     s.pushcfunction(dummy);
     assert_eq!(s.typename(-1), "function");
 
-    extern "C" fn dummy(_L: *mut ::raw::lua_State) -> ::libc::c_int {
+    unsafe extern "C" fn dummy(_L: *mut ::raw::lua_State) -> ::libc::c_int {
         0
     }
 }
@@ -117,7 +117,7 @@ fn test_tocfunction() {
     s.pushcfunction(cfunc);
     assert_eq!(s.tocfunction(2).map(|f| f as *const ()), Some(cfunc as *const ()));
 
-    extern "C" fn cfunc(_L: *mut raw::lua_State) -> libc::c_int { 0 }
+    unsafe extern "C" fn cfunc(_L: *mut raw::lua_State) -> libc::c_int { 0 }
 }
 
 #[test]