Merge branch 'wrong-type-verbosity' into 'master'

feat(lua_ffi): make WrongType error more verbose

See merge request picodata/brod/tarantool-module!49

Author: rosik

hlua/ffi/src/lib.rs

@@ -112,6 +112,7 @@ extern "C" {
     pub fn lua_gettable(l: *mut lua_State, index: c_int);
     pub fn lua_settable(l: *mut lua_State, idx: c_int);
     pub fn lua_type(state: *mut lua_State, index: c_int) -> c_int;
+    pub fn lua_typename(state: *mut lua_State, tp: c_int) -> *mut c_schar;
     pub fn lua_setmetatable(l: *mut lua_State, objindex: c_int) -> c_int;
     pub fn lua_getmetatable(l: *mut lua_State, objindex: c_int) -> c_int;
 

hlua/hlua/src/lib.rs

@@ -408,7 +408,10 @@ pub enum LuaError {
     ReadError(IoError),
 
     /// The call to `execute` has requested the wrong type of data.
-    WrongType,
+    WrongType{
+        rust_expected: String,
+        lua_actual: String,
+    },
 }
 
 impl fmt::Display for LuaError {
@@ -419,7 +422,10 @@ impl fmt::Display for LuaError {
             SyntaxError(ref s) => write!(f, "Syntax error: {}", s),
             ExecutionError(ref s) => write!(f, "Execution error: {}", s),
             ReadError(ref e) => write!(f, "Read error: {}", e),
-            WrongType => write!(f, "Wrong type returned by Lua"),
+            WrongType{
+                rust_expected: ref e1,
+                lua_actual: ref e2
+            } => write!(f, "Wrong type returned by Lua: {} expected, got {}", e1, e2),
         }
     }
 }
@@ -432,7 +438,7 @@ impl Error for LuaError {
             SyntaxError(ref s) => &s,
             ExecutionError(ref s) => &s,
             ReadError(_) => "read error",
-            WrongType => "wrong type returned by Lua",
+            WrongType{rust_expected: _, lua_actual: _} => "wrong type returned by Lua",
         }
     }
 
@@ -443,7 +449,7 @@ impl Error for LuaError {
             SyntaxError(_) => None,
             ExecutionError(_) => None,
             ReadError(ref e) => Some(e),
-            WrongType => None,
+            WrongType{rust_expected: _, lua_actual: _} => None,
         }
     }
 }

hlua/hlua/src/lua_functions.rs

@@ -284,7 +284,14 @@ impl<'lua, L> LuaFunction<L>
 
         match pcall_return_value {
             0 => match LuaRead::lua_read(pushed_value) {
-                Err(_) => Err(LuaFunctionCallError::LuaError(LuaError::WrongType)),
+                Err(lua) => Err(LuaFunctionCallError::LuaError(LuaError::WrongType{
+                    rust_expected: std::any::type_name::<V>().to_string(),
+                    lua_actual: unsafe {
+                        let lua_type = ffi::lua_type(lua.raw_lua.state_ptr(), -1);
+                        let typename = ffi::lua_typename(lua.raw_lua.state_ptr(), lua_type);
+                        std::ffi::CStr::from_ptr(typename).to_string_lossy().into_owned()
+                    }
+                })),
                 Ok(x) => Ok(x),
             },
             ffi::LUA_ERRMEM => panic!("lua_pcall returned LUA_ERRMEM"),

tests/src/hlua/lua_functions.rs

@@ -44,13 +44,26 @@ pub fn execution_error() {
     };
 }
 
-pub fn wrong_type() {
+pub fn check_types() {
     let mut lua = crate::hlua::global();
     let mut f = LuaFunction::load(&mut lua, "return 12").unwrap();
-    match f.call::<LuaFunction<_>>() {
-        Err(LuaError::WrongType) => (),
-        _ => panic!(),
+    let err = f.call::<bool>().unwrap_err();
+    match err {
+        LuaError::WrongType{ref rust_expected, ref lua_actual} => {
+            assert_eq!(rust_expected, "bool");
+            assert_eq!(lua_actual, "number");
+        },
+        v => panic!("{}", v),
     };
+    assert_eq!(
+        err.to_string(),
+        "Wrong type returned by Lua: bool expected, got number"
+    );
+
+    assert_eq!(f.call::<i32>().unwrap(), 12i32);
+    assert_eq!(f.call::<f32>().unwrap(), 12f32);
+    assert_eq!(f.call::<f64>().unwrap(), 12f64);
+    assert_eq!(f.call::<String>().unwrap(), "12".to_string());
 }
 
 pub fn call_and_read_table() {

tests/src/lib.rs

@@ -183,7 +183,7 @@ fn run_tests(cfg: TestConfig) -> Result<bool, io::Error> {
                 hlua::lua_functions::args_in_order,
                 hlua::lua_functions::syntax_error,
                 hlua::lua_functions::execution_error,
-                hlua::lua_functions::wrong_type,
+                hlua::lua_functions::check_types,
                 hlua::lua_functions::call_and_read_table,
                 hlua::lua_functions::lua_function_returns_function,
                 hlua::lua_functions::execute_from_reader_errors_if_cant_read,