Clippies

Signed-off-by: itowlson <ivan.towlson@fermyon.com>

Author: itowlson

crates/blobstore-azure/src/store/incoming_data.rs

@@ -38,8 +38,7 @@ impl AzureIncomingData {
     fn consume_as_stream(&mut self) -> impl futures::stream::Stream<Item = Result<Vec<u8>, std::io::Error>> {
         let opt_stm = self.stm.get_mut();
         let stm = opt_stm.take().unwrap();
-        let byte_stm = stm.flat_map(|chunk| streamify_chunk(chunk.unwrap().data));
-        byte_stm
+        stm.flat_map(|chunk| streamify_chunk(chunk.unwrap().data))
     }
 }
 

crates/blobstore-azure/src/store/object_names.rs

@@ -63,14 +63,14 @@ impl AzureObjectNames {
 
         if names.len() <= len {
             // We can send them all!
-            return Ok((names, at_end));
+            Ok((names, at_end))
         } else {
             // We have more names than we can send in this response. Send what we can and
             // stash the rest.
             let to_return: Vec<_> = names.drain(0..len).collect();
             self.read_but_not_yet_returned = names;
             self.end_stm_after_read_but_not_yet_returned = at_end;
-            return Ok((to_return, false));
+            Ok((to_return, false))
         }
     }
 }

crates/blobstore-s3/src/store.rs

@@ -267,8 +267,7 @@ impl S3IncomingData {
         let rr = self.get_obj_resp.take().expect("get object resp was already consumed");
         let ar = rr.body.into_async_read();
         let s = tokio_util::io::ReaderStream::new(ar);
-        let vec_stm = s.map(|by| by.map(|b| b.to_vec()));
-        vec_stm
+        s.map(|by| by.map(|b| b.to_vec()))
     }
 }
 
@@ -319,14 +318,14 @@ impl S3BlobsList {
 
         if names.len() <= len {
             // We can send them all!
-            return Ok((names, at_end));
+            Ok((names, at_end))
         } else {
             // We have more names than we can send in this response. Send what we can and
             // stash the rest.
             let to_return: Vec<_> = names.drain(0..len).collect();
             self.read_but_not_yet_returned = names;
             self.end_stm_after_read_but_not_yet_returned = at_end;
-            return Ok((to_return, false));
+            Ok((to_return, false))
         }
     }
 }

crates/factor-blobstore/src/host.rs

@@ -126,7 +126,7 @@ pub struct WasiImplInner<'a> {
     pub table: &'a mut ResourceTable,
 }
 
-impl<'a> wasmtime_wasi::WasiView for WasiImplInner<'a> {
+impl wasmtime_wasi::WasiView for WasiImplInner<'_> {
     fn ctx(&mut self) -> &mut wasmtime_wasi::WasiCtx {
         self.ctx
     }
@@ -171,7 +171,7 @@ impl<'a> BlobStoreDispatch<'a> {
     }
 }
 
-impl<'a> wb::Host for BlobStoreDispatch<'a> {
+impl wb::Host for BlobStoreDispatch<'_> {
     async fn create_container(&mut self, _name: String) -> Result<Resource<wbc::Container>, String> {
         Err("This version of Spin does not support creating containers".to_owned())
     }
@@ -208,13 +208,13 @@ impl<'a> wb::Host for BlobStoreDispatch<'a> {
     }
 }
 
-impl<'a> wbt::Host for BlobStoreDispatch<'a> {
+impl wbt::Host for BlobStoreDispatch<'_> {
     fn convert_error(&mut self, error: String) -> anyhow::Result<String> {
         Ok(error)
     }
 }
 
-impl<'a> wbt::HostIncomingValue for BlobStoreDispatch<'a> {
+impl wbt::HostIncomingValue for BlobStoreDispatch<'_> {
     async fn incoming_value_consume_sync(&mut self, self_: Resource<wbt::IncomingValue>) -> Result<Vec<u8>, String> {
         let mut incoming = self.take_incoming_value(self_).await?;
         incoming.as_mut().consume_sync().await.map_err(|e| e.to_string())
@@ -240,7 +240,7 @@ impl<'a> wbt::HostIncomingValue for BlobStoreDispatch<'a> {
     }
 }
 
-impl<'a> wbt::HostOutgoingValue for BlobStoreDispatch<'a> {
+impl wbt::HostOutgoingValue for BlobStoreDispatch<'_> {
     async fn new_outgoing_value(&mut self) -> anyhow::Result<Resource<wbt::OutgoingValue>> {
         let outgoing_value = OutgoingValue::new();
         let rep = self.outgoing_values.write().await.push(outgoing_value).unwrap();
@@ -286,9 +286,9 @@ impl<'a> wbt::HostOutgoingValue for BlobStoreDispatch<'a> {
 }
 
 // TODO: TBD if these belong on BSD or some other struct (like the one that maps to a Container resource JUST SAYIN)
-impl<'a> wbc::Host for BlobStoreDispatch<'a> {}
+impl wbc::Host for BlobStoreDispatch<'_> {}
 
-impl<'a> wbc::HostContainer for BlobStoreDispatch<'a> {
+impl wbc::HostContainer for BlobStoreDispatch<'_> {
     async fn name(&mut self, self_: Resource<wbc::Container>) -> Result<String, String> {
         let lock = self.containers.read().await;
         let container = lock.get(self_.rep()).ok_or_else(||
@@ -387,7 +387,7 @@ impl<'a> wbc::HostContainer for BlobStoreDispatch<'a> {
     }
 }
 
-impl<'a> wbc::HostStreamObjectNames for BlobStoreDispatch<'a> {
+impl wbc::HostStreamObjectNames for BlobStoreDispatch<'_> {
     async fn read_stream_object_names(&mut self, self_: Resource<wbc::StreamObjectNames>, len: u64) -> Result<(Vec<String>,bool), String> {
         let mut lock = self.object_names.write().await;
         let object_names = lock.get_mut(self_.rep()).ok_or_else(||

crates/factor-blobstore/src/stream/write_stream.rs

@@ -68,9 +68,7 @@ impl Worker {
     }
     fn check_write(&self) -> Result<usize, StreamError> {
         let mut state = self.state();
-        if let Err(e) = state.check_error() {
-            return Err(e);
-        }
+        state.check_error()?;
 
         if state.flush_pending || state.shutdown_pending || state.write_budget == 0 {
             return Ok(0);
@@ -256,10 +254,9 @@ impl HostOutputStream for AsyncWriteStream {
         if let Some(handle) = self.shutdown_join_handle.take() {
             handle.abort();
         };
-        match self.join_handle.take() {
-            Some(task) => _ = cancel(task).await,
-            None => {}
-        }
+        if let Some(task) = self.join_handle.take() {
+            _ = cancel(task).await;
+        };
     }
 }
 #[spin_core::async_trait]