From 566372c7360d643cc178f21fbeb10b4e2c0d305b Mon Sep 17 00:00:00 2001 From: Chris Dickinson Date: Tue, 30 Jul 2024 11:41:39 -0700 Subject: [PATCH] fix: address clippy::needless_borrows_for_generic_args --- runtime/src/current_plugin.rs | 58 +++++++++--------- runtime/src/plugin.rs | 26 ++++---- runtime/src/tests/kernel.rs | 108 ++++++++++++---------------------- runtime/src/tests/runtime.rs | 2 +- 4 files changed, 82 insertions(+), 112 deletions(-) diff --git a/runtime/src/current_plugin.rs b/runtime/src/current_plugin.rs index b91c0e9..a2fb0be 100644 --- a/runtime/src/current_plugin.rs +++ b/runtime/src/current_plugin.rs @@ -160,10 +160,10 @@ impl CurrentPlugin { } pub fn memory_bytes_mut(&mut self, handle: MemoryHandle) -> Result<&mut [u8], Error> { - let (linker, mut store) = self.linker_and_store(); - if let Some(mem) = linker.get(&mut store, EXTISM_ENV_MODULE, "memory") { + let (linker, store) = self.linker_and_store(); + if let Some(mem) = linker.get(&mut *store, EXTISM_ENV_MODULE, "memory") { let mem = mem.into_memory().unwrap(); - let ptr = unsafe { mem.data_ptr(&store).add(handle.offset() as usize) }; + let ptr = unsafe { mem.data_ptr(&*store).add(handle.offset() as usize) }; if ptr.is_null() { return Ok(&mut []); } @@ -174,10 +174,10 @@ impl CurrentPlugin { } pub fn memory_bytes(&mut self, handle: MemoryHandle) -> Result<&[u8], Error> { - let (linker, mut store) = self.linker_and_store(); - if let Some(mem) = linker.get(&mut store, EXTISM_ENV_MODULE, "memory") { + let (linker, store) = self.linker_and_store(); + if let Some(mem) = linker.get(&mut *store, EXTISM_ENV_MODULE, "memory") { let mem = mem.into_memory().unwrap(); - let ptr = unsafe { mem.data_ptr(&store).add(handle.offset() as usize) }; + let ptr = unsafe { mem.data_ptr(&*store).add(handle.offset() as usize) }; if ptr.is_null() { return Ok(&[]); } @@ -188,17 +188,17 @@ impl CurrentPlugin { } pub fn host_context(&mut self) -> Result { - let (linker, mut store) = self.linker_and_store(); - let Some(Extern::Global(xs)) = linker.get(&mut store, EXTISM_ENV_MODULE, "extism_context") + let (linker, store) = self.linker_and_store(); + let Some(Extern::Global(xs)) = linker.get(&mut *store, EXTISM_ENV_MODULE, "extism_context") else { anyhow::bail!("unable to locate an extism kernel global: extism_context",) }; - let Val::ExternRef(Some(xs)) = xs.get(&mut store) else { + let Val::ExternRef(Some(xs)) = xs.get(&mut *store) else { anyhow::bail!("expected extism_context to be an externref value",) }; - match xs.data(&mut store)?.downcast_ref::().cloned() { + match xs.data(&mut *store)?.downcast_ref::().cloned() { Some(xs) => Ok(xs.clone()), None => anyhow::bail!("could not downcast extism_context",), } @@ -216,7 +216,7 @@ impl CurrentPlugin { if let Some(f) = linker.get(&mut store, EXTISM_ENV_MODULE, "alloc") { f.into_func() .unwrap() - .call(&mut store, &[Val::I64(n as i64)], output)?; + .call(&mut *store, &[Val::I64(n as i64)], output)?; } else { anyhow::bail!("{} unable to allocate memory", self.id); } @@ -238,11 +238,11 @@ impl CurrentPlugin { /// Free a block of Extism plugin memory pub fn memory_free(&mut self, handle: MemoryHandle) -> Result<(), Error> { - let (linker, mut store) = self.linker_and_store(); - if let Some(f) = linker.get(&mut store, EXTISM_ENV_MODULE, "free") { + let (linker, store) = self.linker_and_store(); + if let Some(f) = linker.get(&mut *store, EXTISM_ENV_MODULE, "free") { f.into_func() .unwrap() - .call(&mut store, &[Val::I64(handle.offset as i64)], &mut [])?; + .call(&mut *store, &[Val::I64(handle.offset as i64)], &mut [])?; } else { anyhow::bail!("unable to locate an extism kernel function: free",) } @@ -250,12 +250,12 @@ impl CurrentPlugin { } pub fn memory_length(&mut self, offs: u64) -> Result { - let (linker, mut store) = self.linker_and_store(); + let (linker, store) = self.linker_and_store(); let output = &mut [Val::I64(0)]; - if let Some(f) = linker.get(&mut store, EXTISM_ENV_MODULE, "length") { + if let Some(f) = linker.get(&mut *store, EXTISM_ENV_MODULE, "length") { f.into_func() .unwrap() - .call(&mut store, &[Val::I64(offs as i64)], output)?; + .call(&mut *store, &[Val::I64(offs as i64)], output)?; } else { anyhow::bail!("unable to locate an extism kernel function: length",) } @@ -270,12 +270,12 @@ impl CurrentPlugin { } pub fn memory_length_unsafe(&mut self, offs: u64) -> Result { - let (linker, mut store) = self.linker_and_store(); + let (linker, store) = self.linker_and_store(); let output = &mut [Val::I64(0)]; - if let Some(f) = linker.get(&mut store, EXTISM_ENV_MODULE, "length_unsafe") { + if let Some(f) = linker.get(&mut *store, EXTISM_ENV_MODULE, "length_unsafe") { f.into_func() .unwrap() - .call(&mut store, &[Val::I64(offs as i64)], output)?; + .call(&mut *store, &[Val::I64(offs as i64)], output)?; } else { anyhow::bail!("unable to locate an extism kernel function: length_unsafe",) } @@ -414,12 +414,12 @@ impl CurrentPlugin { /// Clear the current plugin error pub fn clear_error(&mut self) { trace!(plugin = self.id.to_string(), "CurrentPlugin::clear_error"); - let (linker, mut store) = self.linker_and_store(); - if let Some(f) = linker.get(&mut store, EXTISM_ENV_MODULE, "error_set") { + let (linker, store) = self.linker_and_store(); + if let Some(f) = linker.get(&mut *store, EXTISM_ENV_MODULE, "error_set") { let res = f .into_func() .unwrap() - .call(&mut store, &[Val::I64(0)], &mut []); + .call(&mut *store, &[Val::I64(0)], &mut []); if let Err(e) = res { error!( plugin = self.id.to_string(), @@ -451,10 +451,10 @@ impl CurrentPlugin { let s = s.as_ref(); debug!(plugin = self.id.to_string(), "set error: {:?}", s); let handle = self.current_plugin_mut().memory_new(s)?; - let (linker, mut store) = self.linker_and_store(); - if let Some(f) = linker.get(&mut store, EXTISM_ENV_MODULE, "error_set") { + let (linker, store) = self.linker_and_store(); + if let Some(f) = linker.get(&mut *store, EXTISM_ENV_MODULE, "error_set") { f.into_func().unwrap().call( - &mut store, + &mut *store, &[Val::I64(handle.offset() as i64)], &mut [], )?; @@ -465,10 +465,10 @@ impl CurrentPlugin { } pub(crate) fn get_error_position(&mut self) -> (u64, u64) { - let (linker, mut store) = self.linker_and_store(); + let (linker, store) = self.linker_and_store(); let output = &mut [Val::I64(0)]; - if let Some(f) = linker.get(&mut store, EXTISM_ENV_MODULE, "error_get") { - if let Err(e) = f.into_func().unwrap().call(&mut store, &[], output) { + if let Some(f) = linker.get(&mut *store, EXTISM_ENV_MODULE, "error_get") { + if let Err(e) = f.into_func().unwrap().call(&mut *store, &[], output) { error!( plugin = self.id.to_string(), "unable to call extism:host/env::error_get: {:?}", e diff --git a/runtime/src/plugin.rs b/runtime/src/plugin.rs index 9c2b792..7fedd96 100644 --- a/runtime/src/plugin.rs +++ b/runtime/src/plugin.rs @@ -612,17 +612,17 @@ impl Plugin { // Initialize the guest runtime pub(crate) fn initialize_guest_runtime(&mut self) -> Result<(), Error> { - let mut store = &mut self.store; + let store = &mut self.store; if let Some(runtime) = &self.runtime { trace!(plugin = self.id.to_string(), "Plugin::initialize_runtime"); match runtime { GuestRuntime::Haskell { init, reactor_init } => { if let Some(reactor_init) = reactor_init { - reactor_init.call(&mut store, &[], &mut [])?; + reactor_init.call(&mut *store, &[], &mut [])?; } - let mut results = vec![Val::I32(0); init.ty(&store).results().len()]; + let mut results = vec![Val::I32(0); init.ty(&*store).results().len()]; init.call( - &mut store, + &mut *store, &[Val::I32(0), Val::I32(0)], results.as_mut_slice(), )?; @@ -632,7 +632,7 @@ impl Plugin { ); } GuestRuntime::Wasi { init } => { - init.call(&mut store, &[], &mut [])?; + init.call(&mut *store, &[], &mut [])?; debug!(plugin = self.id.to_string(), "initialied WASI runtime"); } } @@ -645,20 +645,20 @@ impl Plugin { fn output_memory_position(&mut self) -> Result<(u64, u64), Error> { let out = &mut [Val::I64(0)]; let out_len = &mut [Val::I64(0)]; - let mut store = &mut self.store; + let store = &mut self.store; if let Some(f) = self .linker - .get(&mut store, EXTISM_ENV_MODULE, "output_offset") + .get(&mut *store, EXTISM_ENV_MODULE, "output_offset") { - f.into_func().unwrap().call(&mut store, &[], out)?; + f.into_func().unwrap().call(&mut *store, &[], out)?; } else { anyhow::bail!("unable to set output") } if let Some(f) = self .linker - .get(&mut store, EXTISM_ENV_MODULE, "output_length") + .get(&mut *store, EXTISM_ENV_MODULE, "output_length") { - f.into_func().unwrap().call(&mut store, &[], out_len)?; + f.into_func().unwrap().call(&mut *store, &[], out_len)?; } else { anyhow::bail!("unable to set output length") } @@ -957,11 +957,11 @@ impl Plugin { pub(crate) fn clear_error(&mut self) -> Result<(), Error> { trace!(plugin = self.id.to_string(), "clearing error"); - let (linker, mut store) = self.linker_and_store(); - if let Some(f) = linker.get(&mut store, EXTISM_ENV_MODULE, "error_set") { + let (linker, store) = self.linker_and_store(); + if let Some(f) = linker.get(&mut *store, EXTISM_ENV_MODULE, "error_set") { f.into_func() .unwrap() - .call(&mut store, &[Val::I64(0)], &mut [])?; + .call(store, &[Val::I64(0)], &mut [])?; Ok(()) } else { anyhow::bail!("Plugin::clear_error failed, extism:host/env::error_set not found") diff --git a/runtime/src/tests/kernel.rs b/runtime/src/tests/kernel.rs index 6960b5a..cdb448d 100644 --- a/runtime/src/tests/kernel.rs +++ b/runtime/src/tests/kernel.rs @@ -3,36 +3,32 @@ use quickcheck::*; const KERNEL: &[u8] = include_bytes!("../extism-runtime.wasm"); -fn extism_alloc(mut store: &mut wasmtime::Store, instance: &mut Instance, n: u64) -> u64 { +fn extism_alloc(store: &mut wasmtime::Store, instance: &mut Instance, n: u64) -> u64 { let out_alloc = &mut [Val::I64(0)]; instance - .get_func(&mut store, "alloc") + .get_func(&mut *store, "alloc") .unwrap() - .call(&mut store, &[Val::I64(n as i64)], out_alloc) + .call(store, &[Val::I64(n as i64)], out_alloc) .unwrap(); out_alloc[0].unwrap_i64() as u64 } -fn extism_length(mut store: &mut wasmtime::Store, instance: &mut Instance, p: u64) -> u64 { +fn extism_length(store: &mut wasmtime::Store, instance: &mut Instance, p: u64) -> u64 { let out = &mut [Val::I64(0)]; instance - .get_func(&mut store, "length") + .get_func(&mut *store, "length") .unwrap() - .call(&mut store, &[Val::I64(p as i64)], out) + .call(store, &[Val::I64(p as i64)], out) .unwrap(); out[0].unwrap_i64() as u64 } -fn extism_length_unsafe( - mut store: &mut wasmtime::Store, - instance: &mut Instance, - p: u64, -) -> u64 { +fn extism_length_unsafe(store: &mut wasmtime::Store, instance: &mut Instance, p: u64) -> u64 { let out = &mut [Val::I64(0)]; instance - .get_func(&mut store, "length_unsafe") + .get_func(&mut *store, "length_unsafe") .unwrap() - .call(&mut store, &[Val::I64(p as i64)], out) + .call(store, &[Val::I64(p as i64)], out) .unwrap(); out[0].unwrap_i64() as u64 } @@ -47,122 +43,96 @@ fn extism_load_u8(mut store: &mut wasmtime::Store, instance: &mut Instance out[0].unwrap_i32() as u8 } -fn extism_load_u64(mut store: &mut wasmtime::Store, instance: &mut Instance, p: u64) -> u64 { +fn extism_load_u64(store: &mut wasmtime::Store, instance: &mut Instance, p: u64) -> u64 { let out = &mut [Val::I32(0)]; instance - .get_func(&mut store, "load_u64") + .get_func(&mut *store, "load_u64") .unwrap() - .call(&mut store, &[Val::I64(p as i64)], out) + .call(store, &[Val::I64(p as i64)], out) .unwrap(); out[0].unwrap_i64() as u64 } -fn extism_input_load_u8( - mut store: &mut wasmtime::Store, - instance: &mut Instance, - p: u64, -) -> u8 { +fn extism_input_load_u8(store: &mut wasmtime::Store, instance: &mut Instance, p: u64) -> u8 { let out = &mut [Val::I32(0)]; instance - .get_func(&mut store, "input_load_u8") + .get_func(&mut *store, "input_load_u8") .unwrap() - .call(&mut store, &[Val::I64(p as i64)], out) + .call(store, &[Val::I64(p as i64)], out) .unwrap(); out[0].unwrap_i32() as u8 } fn extism_input_load_u64( - mut store: &mut wasmtime::Store, + store: &mut wasmtime::Store, instance: &mut Instance, p: u64, ) -> u64 { let out = &mut [Val::I32(0)]; instance - .get_func(&mut store, "input_load_u64") + .get_func(&mut *store, "input_load_u64") .unwrap() - .call(&mut store, &[Val::I64(p as i64)], out) + .call(store, &[Val::I64(p as i64)], out) .unwrap(); out[0].unwrap_i64() as u64 } -fn extism_store_u8(mut store: &mut wasmtime::Store, instance: &mut Instance, p: u64, x: u8) { +fn extism_store_u8(store: &mut wasmtime::Store, instance: &mut Instance, p: u64, x: u8) { instance - .get_func(&mut store, "store_u8") + .get_func(&mut *store, "store_u8") .unwrap() - .call( - &mut store, - &[Val::I64(p as i64), Val::I32(x as i32)], - &mut [], - ) + .call(store, &[Val::I64(p as i64), Val::I32(x as i32)], &mut []) .unwrap(); } -fn extism_store_u64( - mut store: &mut wasmtime::Store, - instance: &mut Instance, - p: u64, - x: u64, -) { +fn extism_store_u64(store: &mut wasmtime::Store, instance: &mut Instance, p: u64, x: u64) { instance - .get_func(&mut store, "store_u64") + .get_func(&mut *store, "store_u64") .unwrap() - .call( - &mut store, - &[Val::I64(p as i64), Val::I64(x as i64)], - &mut [], - ) + .call(store, &[Val::I64(p as i64), Val::I64(x as i64)], &mut []) .unwrap(); } -fn extism_free(mut store: &mut wasmtime::Store, instance: &mut Instance, p: u64) { +fn extism_free(store: &mut wasmtime::Store, instance: &mut Instance, p: u64) { instance - .get_func(&mut store, "free") + .get_func(&mut *store, "free") .unwrap() - .call(&mut store, &[Val::I64(p as i64)], &mut []) + .call(store, &[Val::I64(p as i64)], &mut []) .unwrap(); } -fn extism_error_set(mut store: &mut wasmtime::Store, instance: &mut Instance, p: u64) { +fn extism_error_set(store: &mut wasmtime::Store, instance: &mut Instance, p: u64) { instance - .get_func(&mut store, "error_set") + .get_func(&mut *store, "error_set") .unwrap() - .call(&mut store, &[Val::I64(p as i64)], &mut []) + .call(store, &[Val::I64(p as i64)], &mut []) .unwrap(); } -fn extism_error_get(mut store: &mut wasmtime::Store, instance: &mut Instance) -> u64 { +fn extism_error_get(store: &mut wasmtime::Store, instance: &mut Instance) -> u64 { let out = &mut [Val::I64(0)]; instance - .get_func(&mut store, "error_get") + .get_func(&mut *store, "error_get") .unwrap() - .call(&mut store, &[], out) + .call(store, &[], out) .unwrap(); out[0].unwrap_i64() as u64 } -fn extism_reset(mut store: &mut wasmtime::Store, instance: &mut Instance) { +fn extism_reset(store: &mut wasmtime::Store, instance: &mut Instance) { instance - .get_func(&mut store, "reset") + .get_func(&mut *store, "reset") .unwrap() - .call(&mut store, &[], &mut []) + .call(store, &[], &mut []) .unwrap(); } -fn extism_input_set( - mut store: &mut wasmtime::Store, - instance: &mut Instance, - p: u64, - l: u64, -) { +fn extism_input_set(store: &mut wasmtime::Store, instance: &mut Instance, p: u64, l: u64) { instance - .get_func(&mut store, "input_set") + .get_func(&mut *store, "input_set") .unwrap() - .call( - &mut store, - &[Val::I64(p as i64), Val::I64(l as i64)], - &mut [], - ) + .call(store, &[Val::I64(p as i64), Val::I64(l as i64)], &mut []) .unwrap(); } diff --git a/runtime/src/tests/runtime.rs b/runtime/src/tests/runtime.rs index aa1608f..f4ddc55 100644 --- a/runtime/src/tests/runtime.rs +++ b/runtime/src/tests/runtime.rs @@ -768,7 +768,7 @@ fn test_readonly_dirs() { assert_eq!(res, "hello world!"); let line = "hello world 2"; - let res2 = plugin.call::<&str, &str>("try_write", &line); + let res2 = plugin.call::<&str, &str>("try_write", line); assert!( res2.is_err(), "Expected try_write to fail, but it succeeded."