Provisional "fix" for #71. Requires nightly :(

Cargo.toml

@@ -22,6 +22,12 @@ default = ["builtin-lua"]
 #   * LUA_NUMBER as double
 #   * LUA_EXTRASPACE is sizeof(void*)
 builtin-lua = ["gcc"]
+# Error handling is completely broken on windows with
+# https://github.com/rust-lang/rust/pull/46833 merged, and this includes stable
+# rustc 1.24.0+.  This feature fixes error handling on windows, but requires
+# nightly!  See https://github.com/rust-lang/rust/issues/48251 and
+# https://github.com/chucklefish/rlua/issues/71 for details.
+unwind = []
 
 [dependencies]
 libc = { version = "0.2" }

src/function.rs

@@ -122,6 +122,7 @@ impl<'lua> Function<'lua> {
     /// # }
     /// ```
     pub fn bind<A: ToLuaMulti<'lua>>(&self, args: A) -> Result<Function<'lua>> {
+        #[cfg_attr(feature = "unwind", unwind)]
         unsafe extern "C" fn bind_call_impl(state: *mut ffi::lua_State) -> c_int {
             let nargs = ffi::lua_gettop(state);
             let nbinds = ffi::lua_tointeger(state, ffi::lua_upvalueindex(2)) as c_int;

src/lib.rs

@@ -1,3 +1,5 @@
+#![cfg_attr(feature = "unwind", feature(unwind_attributes))]
+
 //! # High-level bindings to Lua
 //!
 //! The `rlua` crate provides safe high-level bindings to the [Lua programming language].

src/lua.rs

@@ -759,6 +759,7 @@ impl Lua {
     pub(crate) unsafe fn userdata_metatable<T: UserData>(&self) -> Result<c_int> {
         // Used if both an __index metamethod is set and regular methods, checks methods table
         // first, then __index metamethod.
+        #[cfg_attr(feature = "unwind", unwind)]
         unsafe extern "C" fn meta_index_impl(state: *mut ffi::lua_State) -> c_int {
             ffi::luaL_checkstack(state, 2, ptr::null());
 
@@ -994,6 +995,7 @@ impl Lua {
         &'lua self,
         func: Callback<'callback, 'static>,
     ) -> Result<Function<'lua>> {
+        #[cfg_attr(feature = "unwind", unwind)]
         unsafe extern "C" fn callback_call_impl(state: *mut ffi::lua_State) -> c_int {
             callback_error(state, || {
                 let lua = Lua {

src/util.rs

@@ -105,7 +105,7 @@ where
 // limited lua stack.  `nargs` and `nresults` are similar to the parameters of `lua_pcall`, but the
 // given function return type is not the return value count, instead the inner function return
 // values are assumed to match the `nresults` param.  Internally uses 3 extra stack spaces, and does
-// not call checkstack.
+// not call checkstack.  Provided function must *not* panic.
 pub unsafe fn protect_lua_call<F, R>(
     state: *mut ffi::lua_State,
     nargs: c_int,
@@ -121,6 +121,7 @@ where
         nresults: c_int,
     }
 
+    #[cfg_attr(feature = "unwind", unwind)]
     unsafe extern "C" fn do_call<F, R>(state: *mut ffi::lua_State) -> c_int
     where
         F: FnOnce(*mut ffi::lua_State) -> R,
@@ -271,6 +272,7 @@ pub unsafe fn take_userdata<T>(state: *mut ffi::lua_State) -> T {
     ptr::read(ud)
 }
 
+#[cfg_attr(feature = "unwind", unwind)]
 pub unsafe extern "C" fn userdata_destructor<T>(state: *mut ffi::lua_State) -> c_int {
     callback_error(state, || {
         take_userdata::<T>(state);
@@ -291,11 +293,13 @@ where
         Ok(Err(err)) => {
             ffi::luaL_checkstack(state, 2, ptr::null());
             push_wrapped_error(state, err);
+            println!("erroring...");
             ffi::lua_error(state)
         }
         Err(p) => {
             ffi::luaL_checkstack(state, 2, ptr::null());
             push_wrapped_panic(state, p);
+            println!("erroring...");
             ffi::lua_error(state)
         }
     }
@@ -304,6 +308,7 @@ where
 // Takes an error at the top of the stack, and if it is a WrappedError, converts it to an
 // Error::CallbackError with a traceback, if it is some lua type, prints the error along with a
 // traceback, and if it is a WrappedPanic, does not modify it.
+#[cfg_attr(feature = "unwind", unwind)]
 pub unsafe extern "C" fn error_traceback(state: *mut ffi::lua_State) -> c_int {
     ffi::luaL_checkstack(state, 2, ptr::null());
 
@@ -334,6 +339,7 @@ pub unsafe extern "C" fn error_traceback(state: *mut ffi::lua_State) -> c_int {
 }
 
 // A variant of pcall that does not allow lua to catch panic errors from callback_error
+#[cfg_attr(feature = "unwind", unwind)]
 pub unsafe extern "C" fn safe_pcall(state: *mut ffi::lua_State) -> c_int {
     ffi::luaL_checkstack(state, 2, ptr::null());
 
@@ -356,7 +362,9 @@ pub unsafe extern "C" fn safe_pcall(state: *mut ffi::lua_State) -> c_int {
 }
 
 // A variant of xpcall that does not allow lua to catch panic errors from callback_error
+#[cfg_attr(feature = "unwind", unwind)]
 pub unsafe extern "C" fn safe_xpcall(state: *mut ffi::lua_State) -> c_int {
+    #[cfg_attr(feature = "unwind", unwind)]
     unsafe extern "C" fn xpcall_msgh(state: *mut ffi::lua_State) -> c_int {
         ffi::luaL_checkstack(state, 2, ptr::null());
 
@@ -504,6 +512,7 @@ unsafe fn is_wrapped_panic(state: *mut ffi::lua_State, index: c_int) -> bool {
 unsafe fn get_error_metatable(state: *mut ffi::lua_State) -> c_int {
     static ERROR_METATABLE_REGISTRY_KEY: u8 = 0;
 
+    #[cfg_attr(feature = "unwind", unwind)]
     unsafe extern "C" fn error_tostring(state: *mut ffi::lua_State) -> c_int {
         ffi::luaL_checkstack(state, 2, ptr::null());
 
@@ -605,6 +614,7 @@ unsafe fn get_panic_metatable(state: *mut ffi::lua_State) -> c_int {
 unsafe fn get_destructed_userdata_metatable(state: *mut ffi::lua_State) -> c_int {
     static DESTRUCTED_USERDATA_METATABLE: u8 = 0;
 
+    #[cfg_attr(feature = "unwind", unwind)]
     unsafe extern "C" fn destructed_error(state: *mut ffi::lua_State) -> c_int {
         ffi::luaL_checkstack(state, 2, ptr::null());
         push_wrapped_error(state, Error::CallbackDestructed);