Made clippy happy

lib/api/src/sys/imports.rs

@@ -361,7 +361,7 @@ mod test {
                 "small" => g.clone()
             },
             "cat" => {
-                "small" => g.clone()
+                "small" => g
             }
         };
 

lib/api/tests/sys_export.rs

@@ -114,10 +114,10 @@ mod sys {
 
         let host_fn = |env: &MemEnv| {
             let mem = env.memory_ref().unwrap();
-            assert_eq!(is_memory_instance_ref_strong(&mem), Some(false));
+            assert_eq!(is_memory_instance_ref_strong(mem), Some(false));
             let mem_clone = mem.clone();
             assert_eq!(is_memory_instance_ref_strong(&mem_clone), Some(true));
-            assert_eq!(is_memory_instance_ref_strong(&mem), Some(false));
+            assert_eq!(is_memory_instance_ref_strong(mem), Some(false));
         };
 
         let f: TypedFunction<(), ()> = {
@@ -136,7 +136,7 @@ mod sys {
 
             {
                 let mem = instance.exports.get_memory("memory")?;
-                assert_eq!(is_memory_instance_ref_strong(&mem), Some(true));
+                assert_eq!(is_memory_instance_ref_strong(mem), Some(true));
             }
 
             let f: TypedFunction<(), ()> = instance.exports.get_native_function("call_host_fn")?;
@@ -158,10 +158,10 @@ mod sys {
 
         let host_fn = |env: &GlobalEnv| {
             let global = env.global_ref().unwrap();
-            assert_eq!(is_global_instance_ref_strong(&global), Some(false));
+            assert_eq!(is_global_instance_ref_strong(global), Some(false));
             let global_clone = global.clone();
             assert_eq!(is_global_instance_ref_strong(&global_clone), Some(true));
-            assert_eq!(is_global_instance_ref_strong(&global), Some(false));
+            assert_eq!(is_global_instance_ref_strong(global), Some(false));
         };
 
         let f: TypedFunction<(), ()> = {
@@ -180,7 +180,7 @@ mod sys {
 
             {
                 let global = instance.exports.get_global("global")?;
-                assert_eq!(is_global_instance_ref_strong(&global), Some(true));
+                assert_eq!(is_global_instance_ref_strong(global), Some(true));
             }
 
             let f: TypedFunction<(), ()> = instance.exports.get_native_function("call_host_fn")?;
@@ -202,10 +202,10 @@ mod sys {
 
         let host_fn = |env: &TableEnv| {
             let table = env.table_ref().unwrap();
-            assert_eq!(is_table_instance_ref_strong(&table), Some(false));
+            assert_eq!(is_table_instance_ref_strong(table), Some(false));
             let table_clone = table.clone();
             assert_eq!(is_table_instance_ref_strong(&table_clone), Some(true));
-            assert_eq!(is_table_instance_ref_strong(&table), Some(false));
+            assert_eq!(is_table_instance_ref_strong(table), Some(false));
         };
 
         let f: TypedFunction<(), ()> = {
@@ -224,7 +224,7 @@ mod sys {
 
             {
                 let table = instance.exports.get_table("table")?;
-                assert_eq!(is_table_instance_ref_strong(&table), Some(true));
+                assert_eq!(is_table_instance_ref_strong(table), Some(true));
             }
 
             let f: TypedFunction<(), ()> = instance.exports.get_native_function("call_host_fn")?;
@@ -246,10 +246,10 @@ mod sys {
 
         let host_fn = |env: &FunctionEnv| {
             let function = env.call_host_fn_ref().unwrap();
-            assert_eq!(is_function_instance_ref_strong(&function), Some(false));
+            assert_eq!(is_function_instance_ref_strong(function), Some(false));
             let function_clone = function.clone();
             assert_eq!(is_function_instance_ref_strong(&function_clone), Some(true));
-            assert_eq!(is_function_instance_ref_strong(&function), Some(false));
+            assert_eq!(is_function_instance_ref_strong(function), Some(false));
         };
 
         let f: TypedFunction<(), ()> = {
@@ -268,7 +268,7 @@ mod sys {
 
             {
                 let function = instance.exports.get_function("call_host_fn")?;
-                assert_eq!(is_function_instance_ref_strong(&function), Some(true));
+                assert_eq!(is_function_instance_ref_strong(function), Some(true));
             }
 
             let f: TypedFunction<(), ()> = instance.exports.get_native_function("call_host_fn")?;
@@ -291,7 +291,7 @@ mod sys {
         let host_fn = |env: &FunctionEnv| {
             let function = env.call_host_fn_ref().unwrap();
             assert_eq!(
-                is_native_function_instance_ref_strong(&function),
+                is_native_function_instance_ref_strong(function),
                 Some(false)
             );
             let function_clone = function.clone();
@@ -300,7 +300,7 @@ mod sys {
                 Some(true)
             );
             assert_eq!(
-                is_native_function_instance_ref_strong(&function),
+                is_native_function_instance_ref_strong(function),
                 Some(false)
             );
         };

lib/api/tests/sys_externals.rs

@@ -94,7 +94,7 @@ mod sys {
             maximum: Some(1),
         };
         let f = Function::new_native(&store, |num: i32| num + 1);
-        let table = Table::new(&store, table_type, Value::FuncRef(Some(f.clone())))?;
+        let table = Table::new(&store, table_type, Value::FuncRef(Some(f)))?;
         assert_eq!(*table.ty(), table_type);
         let _elem = table.get(0).unwrap();
         // assert_eq!(elem.funcref().unwrap(), f);
@@ -123,7 +123,7 @@ mod sys {
         assert!(old_len.is_err());
 
         // Growing to a bigger maximum should return None
-        let old_len = table.grow(5, Value::FuncRef(Some(f.clone())))?;
+        let old_len = table.grow(5, Value::FuncRef(Some(f)))?;
         assert_eq!(old_len, 0);
 
         Ok(())
@@ -238,11 +238,10 @@ mod sys {
             function.ty().clone(),
             FunctionType::new(vec![], vec![Type::I32])
         );
-        let function = Function::new_native_with_env(
-            &store,
-            my_env.clone(),
-            |_env: &MyEnv| -> (i32, i64, f32, f64) { (1, 2, 3.0, 4.0) },
-        );
+        let function =
+            Function::new_native_with_env(&store, my_env, |_env: &MyEnv| -> (i32, i64, f32, f64) {
+                (1, 2, 3.0, 4.0)
+            });
         assert_eq!(
             function.ty().clone(),
             FunctionType::new(vec![], vec![Type::I32, Type::I64, Type::F32, Type::F64])
@@ -338,7 +337,7 @@ mod sys {
         let function = Function::new_with_env(
             &store,
             function_type,
-            my_env.clone(),
+            my_env,
             |_env: &MyEnv, _values: &[Value]| unimplemented!(),
         );
         assert_eq!(function.ty().params(), [Type::V128]);

lib/api/tests/sys_instance.rs

@@ -50,7 +50,7 @@ mod sys {
 
         fn imported_fn(env: &Env, args: &[Val]) -> Result<Vec<Val>, RuntimeError> {
             let value = env.multiplier * args[0].unwrap_i32() as u32;
-            return Ok(vec![Val::I32(value as _)]);
+            Ok(vec![Val::I32(value as _)])
         }
 
         let imported_signature = FunctionType::new(vec![Type::I32], vec![Type::I32]);

lib/c-api/src/wasm_c_api/wasi/mod.rs

@@ -206,11 +206,11 @@ pub unsafe extern "C" fn wasi_env_read_stdout(
             read_inner(stdout, inner_buffer)
         } else {
             update_last_error("could not find a file handle for `stdout`");
-            return -1;
+            -1
         }
     } else {
         update_last_error("could not find a file handle for `stdout`");
-        return -1;
+        -1
     }
 }
 
@@ -227,11 +227,11 @@ pub unsafe extern "C" fn wasi_env_read_stderr(
             read_inner(stderr, inner_buffer)
         } else {
             update_last_error("could not find a file handle for `stderr`");
-            return -1;
+            -1
         }
     } else {
         update_last_error("could not find a file handle for `stderr`");
-        return -1;
+        -1
     }
 }
 

lib/cache/benches/bench_filesystem_cache.rs

@@ -47,7 +47,7 @@ pub fn load_cache_universal(c: &mut Criterion) {
     fs_cache.store(key, &module).unwrap();
 
     c.bench_function("load universal module in filesystem cache", |b| {
-        b.iter(|| unsafe { fs_cache.load(&store, key.clone()).unwrap() })
+        b.iter(|| unsafe { fs_cache.load(&store, key).unwrap() })
     });
 }
 
@@ -84,7 +84,7 @@ pub fn load_cache_native(c: &mut Criterion) {
     fs_cache.store(key, &module).unwrap();
 
     c.bench_function("load native module in filesystem cache", |b| {
-        b.iter(|| unsafe { fs_cache.load(&store, key.clone()).unwrap() })
+        b.iter(|| unsafe { fs_cache.load(&store, key).unwrap() })
     });
 }
 

lib/cli/src/commands/run/wasi.rs

@@ -98,12 +98,12 @@ impl Wasi {
 
         let mut wasi_env = wasi_state_builder.finalize()?;
         wasi_env.state.fs.is_wasix.store(
-            is_wasix_module(&module),
+            is_wasix_module(module),
             std::sync::atomic::Ordering::Release,
         );
 
         let import_object = wasi_env.import_object_for_all_wasi_versions(module)?;
-        let instance = Instance::new(&module, &import_object)?;
+        let instance = Instance::new(module, &import_object)?;
         Ok(instance)
     }
 

lib/middlewares/src/metering.rs

@@ -382,7 +382,7 @@ mod tests {
     fn get_remaining_points_works() {
         let metering = Arc::new(Metering::new(10, cost_function));
         let mut compiler_config = Cranelift::default();
-        compiler_config.push_middleware(metering.clone());
+        compiler_config.push_middleware(metering);
         let store = Store::new(&Universal::new(compiler_config).engine());
         let module = Module::new(&store, bytecode()).unwrap();
 
@@ -427,7 +427,7 @@ mod tests {
     fn set_remaining_points_works() {
         let metering = Arc::new(Metering::new(10, cost_function));
         let mut compiler_config = Cranelift::default();
-        compiler_config.push_middleware(metering.clone());
+        compiler_config.push_middleware(metering);
         let store = Store::new(&Universal::new(compiler_config).engine());
         let module = Module::new(&store, bytecode()).unwrap();
 

lib/wasi/src/lib.rs

@@ -92,9 +92,9 @@ impl From<u32> for WasiThreadId {
         Self(id)
     }
 }
-impl Into<u32> for WasiThreadId {
-    fn into(self) -> u32 {
-        self.0 as u32
+impl From<WasiThreadId> for u32 {
+    fn from(t: WasiThreadId) -> u32 {
+        t.0 as u32
     }
 }
 
@@ -107,9 +107,9 @@ impl From<u32> for WasiBusProcessId {
         Self(id)
     }
 }
-impl Into<u32> for WasiBusProcessId {
-    fn into(self) -> u32 {
-        self.0 as u32
+impl From<WasiBusProcessId> for u32 {
+    fn from(id: WasiBusProcessId) -> u32 {
+        id.0 as u32
     }
 }
 
@@ -190,7 +190,7 @@ impl WasiEnv {
     }
 
     /// Returns a copy of the current runtime implementation for this environment
-    pub fn runtime<'a>(&'a self) -> &'a (dyn WasiRuntimeImplementation) {
+    pub fn runtime(&self) -> &(dyn WasiRuntimeImplementation) {
         self.runtime.deref()
     }
 
@@ -321,12 +321,12 @@ impl WasiEnv {
     }
 
     /// Accesses the virtual networking implementation
-    pub fn net<'a>(&'a self) -> &'a (dyn VirtualNetworking) {
+    pub fn net(&self) -> &(dyn VirtualNetworking) {
         self.runtime.networking()
     }
 
     /// Accesses the virtual bus implementation
-    pub fn bus<'a>(&'a self) -> &'a (dyn VirtualBus) {
+    pub fn bus(&self) -> &(dyn VirtualBus) {
         self.runtime.bus()
     }
     pub(crate) fn get_memory_and_wasi_state(&self, _mem_index: u32) -> (&Memory, &WasiState) {

lib/wasi/src/runtime.rs

@@ -17,9 +17,9 @@ pub enum WasiThreadError {
     MethodNotFound,
 }
 
-impl Into<__wasi_errno_t> for WasiThreadError {
-    fn into(self) -> __wasi_errno_t {
-        match self {
+impl From<WasiThreadError> for __wasi_errno_t {
+    fn from(a: WasiThreadError) -> __wasi_errno_t {
+        match a {
             WasiThreadError::Unsupported => __WASI_ENOTSUP,
             WasiThreadError::MethodNotFound => __WASI_EINVAL,
         }
@@ -46,11 +46,11 @@ pub trait WasiRuntimeImplementation: fmt::Debug + Sync {
     /// which allows runtimes to pass serialized messages between each other similar to
     /// RPC's. BUS implementation can be implemented that communicate across runtimes
     /// thus creating a distributed computing architecture.
-    fn bus<'a>(&'a self) -> &'a (dyn VirtualBus);
+    fn bus(&self) -> &(dyn VirtualBus);
 
     /// Provides access to all the networking related functions such as sockets.
     /// By default networking is not implemented.
-    fn networking<'a>(&'a self) -> &'a (dyn VirtualNetworking);
+    fn networking(&self) -> &(dyn VirtualNetworking);
 
     /// Generates a new thread ID
     fn thread_generate_id(&self) -> WasiThreadId;
@@ -137,11 +137,11 @@ impl Default for PluggableRuntimeImplementation {
 }
 
 impl WasiRuntimeImplementation for PluggableRuntimeImplementation {
-    fn bus<'a>(&'a self) -> &'a (dyn VirtualBus) {
+    fn bus(&self) -> &(dyn VirtualBus) {
         self.bus.deref()
     }
 
-    fn networking<'a>(&'a self) -> &'a (dyn VirtualNetworking) {
+    fn networking(&self) -> &(dyn VirtualNetworking) {
         self.networking.deref()
     }
 

lib/wasi/src/state/mod.rs

@@ -1232,13 +1232,12 @@ impl WasiFs {
         path: &str,
         follow_symlinks: bool,
     ) -> Result<Inode, __wasi_errno_t> {
-        let start_inode;
-        if path.starts_with("/") == false && self.is_wasix.load(Ordering::Acquire) {
+        let start_inode = if !path.starts_with('/') && self.is_wasix.load(Ordering::Acquire) {
             let (cur_inode, _) = self.get_current_dir(inodes, base)?;
-            start_inode = cur_inode;
+            cur_inode
         } else {
-            start_inode = self.get_fd_inode(base)?;
-        }
+            self.get_fd_inode(base)?
+        };
 
         self.get_inode_at_path_inner(inodes, start_inode, path, 0, follow_symlinks)
     }
@@ -1294,7 +1293,7 @@ impl WasiFs {
         fd: __wasi_fd_t,
     ) -> Result<__wasi_filestat_t, __wasi_errno_t> {
         let inode = self.get_fd_inode(fd)?;
-        Ok(inodes.arena[inode].stat.read().unwrap().deref().clone())
+        Ok(*inodes.arena[inode].stat.read().unwrap().deref())
     }
 
     pub fn fdstat(
@@ -1390,7 +1389,7 @@ impl WasiFs {
                 .stdout_mut(&self.fd_map)
                 .map_err(fs_error_into_wasi_err)?
                 .as_mut()
-                .and_then(|f| Some(f.flush().map_err(map_io_err)))
+                .map(|f| f.flush().map_err(map_io_err))
                 .unwrap_or_else(|| Err(__WASI_EIO))?,
             __WASI_STDERR_FILENO => inodes
                 .stderr_mut(&self.fd_map)
@@ -1406,13 +1405,9 @@ impl WasiFs {
 
                 let mut guard = inodes.arena[fd.inode].write();
                 match guard.deref_mut() {
-                    Kind::File { handle, .. } => {
-                        if let Some(file) = handle {
-                            file.flush().map_err(|_| __WASI_EIO)?
-                        } else {
-                            return Err(__WASI_EIO);
-                        }
-                    }
+                    Kind::File {
+                        handle: Some(file), ..
+                    } => file.flush().map_err(|_| __WASI_EIO)?,
                     // TODO: verify this behavior
                     Kind::Dir { .. } => return Err(__WASI_EISDIR),
                     Kind::Symlink { .. } => unimplemented!("WasiFs::flush Kind::Symlink"),

lib/wasi/src/state/pipe.rs

@@ -109,7 +109,7 @@ impl Read for WasiPipe {
             let data = rx.recv().map_err(|_| {
                 io::Error::new(
                     io::ErrorKind::BrokenPipe,
-                    format!("the wasi pipe is not connected"),
+                    "the wasi pipe is not connected".to_string(),
                 )
             })?;
             self.read_buffer.replace(Bytes::from(data));