io-async: fix warnings for latest nightly (1.75.0)

Fixes `cargo check` warnings for the latest nightly version (`1.75.0`).

Recommended public API signatures for async trait functions has changed
to recommending the desugared version for compatibility with different
`async` runtimes.

Author: rmsyn

embedded-io-async/src/lib.rs

@@ -12,6 +12,8 @@
 #[cfg(feature = "alloc")]
 extern crate alloc;
 
+use core::future::Future;
+
 mod impls;
 
 pub use embedded_io::{
@@ -46,7 +48,7 @@ pub trait Read: ErrorType {
     /// the hardware with e.g. DMA.
     ///
     /// Implementations should document whether they're actually side-effect-free on cancel or not.
-    async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error>;
+    fn read(&mut self, buf: &mut [u8]) -> impl Future<Output = Result<usize, Self::Error>>;
 
     /// Read the exact number of bytes required to fill `buf`.
     ///
@@ -55,18 +57,20 @@ pub trait Read: ErrorType {
     ///
     /// This function is not side-effect-free on cancel (AKA "cancel-safe"), i.e. if you cancel (drop) a returned
     /// future that hasn't completed yet, some bytes might have already been read, which will get lost.
-    async fn read_exact(&mut self, mut buf: &mut [u8]) -> Result<(), ReadExactError<Self::Error>> {
-        while !buf.is_empty() {
-            match self.read(buf).await {
-                Ok(0) => break,
-                Ok(n) => buf = &mut buf[n..],
-                Err(e) => return Err(ReadExactError::Other(e)),
+    fn read_exact(&mut self, mut buf: &mut [u8]) -> impl Future<Output = Result<(), ReadExactError<Self::Error>>> {
+        async move {
+            while !buf.is_empty() {
+                match self.read(buf).await {
+                    Ok(0) => break,
+                    Ok(n) => buf = &mut buf[n..],
+                    Err(e) => return Err(ReadExactError::Other(e)),
+                }
+            }
+            if buf.is_empty() {
+                Ok(())
+            } else {
+                Err(ReadExactError::UnexpectedEof)
             }
-        }
-        if buf.is_empty() {
-            Ok(())
-        } else {
-            Err(ReadExactError::UnexpectedEof)
         }
     }
 }
@@ -82,7 +86,7 @@ pub trait BufRead: ErrorType {
     /// If the reader is at end-of-file (EOF), an empty slice is returned. There is no guarantee that a reader at EOF
     /// will always be so in the future, for example a reader can stop being at EOF if another process appends
     /// more bytes to the underlying file.
-    async fn fill_buf(&mut self) -> Result<&[u8], Self::Error>;
+    fn fill_buf(&mut self) -> impl Future<Output = Result<&[u8], Self::Error>>;
 
     /// Tell this buffer that `amt` bytes have been consumed from the buffer, so they should no longer be returned in calls to `fill_buf`.
     fn consume(&mut self, amt: usize);
@@ -116,11 +120,13 @@ pub trait Write: ErrorType {
     /// the hardware with e.g. DMA.
     ///
     /// Implementations should document whether they're actually side-effect-free on cancel or not.
-    async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error>;
+    fn write(&mut self, buf: &[u8]) -> impl Future<Output = Result<usize, Self::Error>>;
 
     /// Flush this output stream, ensuring that all intermediately buffered contents reach their destination.
-    async fn flush(&mut self) -> Result<(), Self::Error> {
-        Ok(())
+    fn flush(&mut self) -> impl Future<Output = Result<(), Self::Error>> {
+        async {
+            Ok(())
+        }
     }
 
     /// Write an entire buffer into this writer.
@@ -130,16 +136,18 @@ pub trait Write: ErrorType {
     ///
     /// This function is not side-effect-free on cancel (AKA "cancel-safe"), i.e. if you cancel (drop) a returned
     /// future that hasn't completed yet, some bytes might have already been written.
-    async fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Error> {
-        let mut buf = buf;
-        while !buf.is_empty() {
-            match self.write(buf).await {
-                Ok(0) => panic!("write() returned Ok(0)"),
-                Ok(n) => buf = &buf[n..],
-                Err(e) => return Err(e),
+    fn write_all(&mut self, buf: &[u8]) -> impl Future<Output = Result<(), Self::Error>> {
+        async move {
+            let mut buf = buf;
+            while !buf.is_empty() {
+                match self.write(buf).await {
+                    Ok(0) => panic!("write() returned Ok(0)"),
+                    Ok(n) => buf = &buf[n..],
+                    Err(e) => return Err(e),
+                }
             }
+            Ok(())
         }
-        Ok(())
     }
 }
 
@@ -148,52 +156,66 @@ pub trait Write: ErrorType {
 /// This trait is the `embedded-io-async` equivalent of [`std::io::Seek`].
 pub trait Seek: ErrorType {
     /// Seek to an offset, in bytes, in a stream.
-    async fn seek(&mut self, pos: SeekFrom) -> Result<u64, Self::Error>;
+    fn seek(&mut self, pos: SeekFrom) -> impl Future<Output = Result<u64, Self::Error>>;
 
     /// Rewind to the beginning of a stream.
-    async fn rewind(&mut self) -> Result<(), Self::Error> {
-        self.seek(SeekFrom::Start(0)).await?;
-        Ok(())
+    fn rewind(&mut self) -> impl Future<Output = Result<(), Self::Error>> {
+        async move {
+            self.seek(SeekFrom::Start(0)).await?;
+            Ok(())
+        }
     }
 
     /// Returns the current seek position from the start of the stream.
-    async fn stream_position(&mut self) -> Result<u64, Self::Error> {
-        self.seek(SeekFrom::Current(0)).await
+    fn stream_position(&mut self) -> impl Future<Output = Result<u64, Self::Error>> {
+        async move {
+            self.seek(SeekFrom::Current(0)).await
+        }
     }
 }
 
-impl<T: ?Sized + Read> Read for &mut T {
+impl<T: ?Sized + Read + Send> Read for &mut T {
     #[inline]
-    async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
-        T::read(self, buf).await
+    fn read(&mut self, buf: &mut [u8]) -> impl Future<Output = Result<usize, Self::Error>> {
+        async {
+            T::read(self, buf).await
+        }
     }
 }
 
-impl<T: ?Sized + BufRead> BufRead for &mut T {
-    async fn fill_buf(&mut self) -> Result<&[u8], Self::Error> {
-        T::fill_buf(self).await
+impl<T: ?Sized + BufRead + Send> BufRead for &mut T {
+    fn fill_buf(&mut self) -> impl Future<Output = Result<&[u8], Self::Error>> {
+        async {
+            T::fill_buf(self).await
+        }
     }
 
     fn consume(&mut self, amt: usize) {
         T::consume(self, amt);
     }
 }
 
-impl<T: ?Sized + Write> Write for &mut T {
+impl<T: ?Sized + Write + Send> Write for &mut T {
     #[inline]
-    async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
-        T::write(self, buf).await
+    fn write(&mut self, buf: &[u8]) -> impl Future<Output = Result<usize, Self::Error>> {
+        async {
+            T::write(self, buf).await
+        }
     }
 
     #[inline]
-    async fn flush(&mut self) -> Result<(), Self::Error> {
-        T::flush(self).await
+    fn flush(&mut self) -> impl Future<Output = Result<(), Self::Error>> {
+        async {
+            T::flush(self).await
+        }
     }
 }
 
 impl<T: ?Sized + Seek> Seek for &mut T {
     #[inline]
-    async fn seek(&mut self, pos: SeekFrom) -> Result<u64, Self::Error> {
-        T::seek(self, pos).await
+    fn seek(&mut self, pos: SeekFrom) -> impl Future<Output = Result<u64, Self::Error>> {
+        async move {
+            T::seek(self, pos).await
+        }
     }
 }