clippy

Author: khvzak

examples/async_http_client.rs

@@ -13,10 +13,10 @@ impl UserData for BodyReader {
     fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {
         // Every call returns a next chunk
         methods.add_async_method_mut("read", |lua, mut reader, ()| async move {
-            if let Some(bytes) = reader.0.frame().await {
-                if let Some(bytes) = bytes.into_lua_err()?.data_ref() {
-                    return Some(lua.create_string(&bytes)).transpose();
-                }
+            if let Some(bytes) = reader.0.frame().await
+                && let Some(bytes) = bytes.into_lua_err()?.data_ref()
+            {
+                return Some(lua.create_string(bytes)).transpose();
             }
             Ok(None)
         });

examples/guided_tour.rs

@@ -1,4 +1,3 @@
-use std::f32;
 use std::iter::FromIterator;
 
 use mlua::{FromLua, Function, Lua, MetaMethod, Result, UserData, UserDataMethods, Value, Variadic, chunk};
@@ -35,7 +34,7 @@ fn main() -> Result<()> {
     assert_eq!(globals.get::<String>("global")?, "foobar");
 
     assert_eq!(lua.load("1 + 1").eval::<i32>()?, 2);
-    assert_eq!(lua.load("false == false").eval::<bool>()?, true);
+    assert!(lua.load("false == false").eval::<bool>()?);
     assert_eq!(lua.load("return 1 + 2").eval::<i32>()?, 3);
 
     // Use can use special `chunk!` macro to use Rust tokenizer and automatically capture variables
@@ -119,15 +118,13 @@ fn main() -> Result<()> {
     })?;
     globals.set("join", join)?;
 
-    assert_eq!(
+    assert!(
         lua.load(r#"check_equal({"a", "b", "c"}, {"a", "b", "c"})"#)
-            .eval::<bool>()?,
-        true
+            .eval::<bool>()?
     );
-    assert_eq!(
-        lua.load(r#"check_equal({"a", "b", "c"}, {"d", "e", "f"})"#)
-            .eval::<bool>()?,
-        false
+    assert!(
+        !lua.load(r#"check_equal({"a", "b", "c"}, {"d", "e", "f"})"#)
+            .eval::<bool>()?
     );
     assert_eq!(lua.load(r#"join("a", "b", "c")"#).eval::<String>()?, "abc");
 

examples/repl.rs

@@ -20,7 +20,7 @@ fn main() {
             match lua.load(&line).eval::<MultiValue>() {
                 Ok(values) => {
                     editor.add_history_entry(line).unwrap();
-                    if values.len() > 0 {
+                    if !values.is_empty() {
                         println!(
                             "{}",
                             values
@@ -37,7 +37,7 @@ fn main() {
                     ..
                 }) => {
                     // continue reading input and append it to `line`
-                    line.push_str("\n"); // separate input lines
+                    line.push('\n'); // separate input lines
                     prompt = ">> ";
                 }
                 Err(e) => {

src/luau/heap_dump.rs

@@ -168,7 +168,7 @@ fn update_size<K: Eq + Hash>(size_type: &mut HashMap<K, (usize, u64)>, key: K, s
 /// Retrieves the value associated with a given `key` from a Lua table `tbl`.
 fn get_key<'a>(objects: &'a HashMap<&'a str, Json>, tbl: &Json, key: &str) -> Option<&'a str> {
     let pairs = tbl["pairs"].as_array()?;
-    for kv in pairs.chunks_exact(2) {
+    for kv in pairs.as_chunks::<2>().0 {
         #[rustfmt::skip]
         let (Some(key_addr), Some(val_addr)) = (kv[0].as_str(), kv[1].as_str()) else { continue; };
         if objects[key_addr]["type"] == "string" && objects[key_addr]["data"].as_str() == Some(key) {

src/luau/json.rs

@@ -263,8 +263,8 @@ mod tests {
     fn test_numbers() {
         assert_eq!(parse("0").unwrap(), Json::Integer(0));
         assert_eq!(parse("-42").unwrap(), Json::Integer(-42));
-        assert_eq!(parse("3.14").unwrap(), Json::Number(3.14));
-        assert_eq!(parse("-3.14").unwrap(), Json::Number(-3.14));
+        assert_eq!(parse("3.25").unwrap(), Json::Number(3.25));
+        assert_eq!(parse("-3.25").unwrap(), Json::Number(-3.25));
         assert_eq!(parse("1e10").unwrap(), Json::Number(1e10));
         assert_eq!(parse("1E10").unwrap(), Json::Number(1E10));
         assert_eq!(parse("1e-10").unwrap(), Json::Number(1e-10));

src/state/raw.rs

@@ -401,10 +401,8 @@ impl RawLua {
             },
         );
         #[cfg(feature = "luau-jit")]
-        if status == ffi::LUA_OK {
-            if (*self.extra.get()).enable_jit && ffi::luau_codegen_supported() != 0 {
-                ffi::luau_codegen_compile(state, -1);
-            }
+        if status == ffi::LUA_OK && (*self.extra.get()).enable_jit && ffi::luau_codegen_supported() != 0 {
+            ffi::luau_codegen_compile(state, -1);
         }
         status
     }

tests/async.rs

@@ -120,7 +120,7 @@ async fn test_async_call() -> Result<()> {
     assert_eq!(hello.call_async::<String>("alex").await?, "hello, alex!");
 
     // Executing non-async functions using async call is allowed
-    let sum = lua.create_function(|_lua, (a, b): (i64, i64)| return Ok(a + b))?;
+    let sum = lua.create_function(|_lua, (a, b): (i64, i64)| Ok(a + b))?;
     assert_eq!(sum.call_async::<i64>((5, 1)).await?, 6);
 
     Ok(())
@@ -230,7 +230,7 @@ async fn test_async_return_async_closure() -> Result<()> {
 
         let g = lua.create_async_function(move |_, b: i64| async move {
             sleep_ms(10).await;
-            return Ok(a + b);
+            Ok(a + b)
         })?;
 
         Ok(g)

tests/buffer.rs

@@ -25,7 +25,7 @@ fn test_buffer() -> Result<()> {
 
     // Check that we can pass buffer type to Lua
     let buf1 = buf1.as_buffer().unwrap();
-    let func = lua.create_function(|_, buf: Value| return buf.to_string())?;
+    let func = lua.create_function(|_, buf: Value| buf.to_string())?;
     assert!(func.call::<String>(buf1)?.starts_with("buffer:"));
 
     // Check buffer methods

tests/chunk.rs

@@ -50,7 +50,8 @@ fn test_chunk_path() -> Result<()> {
 
     // &Path
     assert_eq!(
-        (lua.load(&*temp_dir.path().join("module.lua").as_path())).eval::<i32>()?,
+        lua.load(temp_dir.path().join("module.lua").as_path())
+            .eval::<i32>()?,
         321
     );
 
@@ -63,14 +64,14 @@ fn test_chunk_impls() -> Result<()> {
 
     // StdString
     assert_eq!(lua.load(String::from("1")).eval::<i32>()?, 1);
-    assert_eq!(lua.load(&String::from("2")).eval::<i32>()?, 2);
+    assert_eq!(lua.load(String::from("2")).eval::<i32>()?, 2);
 
     // &[u8]
     assert_eq!(lua.load(&b"3"[..]).eval::<i32>()?, 3);
 
     // Vec<u8>
     assert_eq!(lua.load(b"4".to_vec()).eval::<i32>()?, 4);
-    assert_eq!(lua.load(&b"5".to_vec()).eval::<i32>()?, 5);
+    assert_eq!(lua.load(b"5".to_vec()).eval::<i32>()?, 5);
 
     Ok(())
 }
@@ -172,7 +173,7 @@ fn test_compiler_library_constants() {
     let lua = Lua::new();
     lua.set_compiler(compiler);
     let const_bool = lua.load("return mylib.const_bool").eval::<bool>().unwrap();
-    assert_eq!(const_bool, true);
+    assert!(const_bool);
     let const_num = lua.load("return mylib.const_num").eval::<f64>().unwrap();
     assert_eq!(const_num, 123.0);
     let const_vec = lua.load("return mylib.const_vec").eval::<Vector>().unwrap();

tests/conversion.rs

@@ -313,7 +313,7 @@ fn test_bool_into_lua() -> Result<()> {
     // Push into stack
     let table = lua.create_table()?;
     table.set("b", true)?;
-    assert_eq!(true, table.get::<bool>("b")?);
+    assert!(table.get::<bool>("b")?);
 
     Ok(())
 }