async: disable Send lint in async traits

Adds `#[allow(async_fn_in_trait)]` to disable the lint in `async` trait
functions recommending `Send` in the return type.

Adding the type annotation is currently unstable, has little-to-no
utility in current crates using `embedded-hal`, and will break those users.

See
<#515 (comment)>
for details and discussion.

Author: rmsyn

embedded-hal-async/src/delay.rs

@@ -4,10 +4,12 @@
 pub trait DelayUs {
     /// Pauses execution for at minimum `us` microseconds. Pause can be longer
     /// if the implementation requires it due to precision/timing issues.
+    #[allow(async_fn_in_trait)]
     async fn delay_us(&mut self, us: u32);
 
     /// Pauses execution for at minimum `ms` milliseconds. Pause can be longer
     /// if the implementation requires it due to precision/timing issues.
+    #[allow(async_fn_in_trait)]
     async fn delay_ms(&mut self, ms: u32);
 }
 
@@ -16,11 +18,13 @@ where
     T: DelayUs + ?Sized,
 {
     #[inline]
+    #[allow(async_fn_in_trait)]
     async fn delay_us(&mut self, us: u32) {
         T::delay_us(self, us).await;
     }
 
     #[inline]
+    #[allow(async_fn_in_trait)]
     async fn delay_ms(&mut self, ms: u32) {
         T::delay_ms(self, ms).await;
     }

embedded-hal-async/src/digital.rs

@@ -23,53 +23,63 @@ pub trait Wait: embedded_hal::digital::ErrorType {
     /// # Note for implementers
     /// The pin may have switched back to low before the task was run after
     /// being woken. The future should still resolve in that case.
+    #[allow(async_fn_in_trait)]
     async fn wait_for_high(&mut self) -> Result<(), Self::Error>;
 
     /// Wait until the pin is low. If it is already low, return immediately.
     ///
     /// # Note for implementers
     /// The pin may have switched back to high before the task was run after
     /// being woken. The future should still resolve in that case.
+    #[allow(async_fn_in_trait)]
     async fn wait_for_low(&mut self) -> Result<(), Self::Error>;
 
     /// Wait for the pin to undergo a transition from low to high.
     ///
     /// If the pin is already high, this does *not* return immediately, it'll wait for the
     /// pin to go low and then high again.
+    #[allow(async_fn_in_trait)]
     async fn wait_for_rising_edge(&mut self) -> Result<(), Self::Error>;
 
     /// Wait for the pin to undergo a transition from high to low.
     ///
     /// If the pin is already low, this does *not* return immediately, it'll wait for the
     /// pin to go high and then low again.
+    #[allow(async_fn_in_trait)]
     async fn wait_for_falling_edge(&mut self) -> Result<(), Self::Error>;
 
     /// Wait for the pin to undergo any transition, i.e low to high OR high to low.
+    #[allow(async_fn_in_trait)]
     async fn wait_for_any_edge(&mut self) -> Result<(), Self::Error>;
 }
 
 impl<T: Wait + ?Sized> Wait for &mut T {
     #[inline]
+    #[allow(async_fn_in_trait)]
     async fn wait_for_high(&mut self) -> Result<(), Self::Error> {
         T::wait_for_high(self).await
     }
 
     #[inline]
+    #[allow(async_fn_in_trait)]
     async fn wait_for_low(&mut self) -> Result<(), Self::Error> {
         T::wait_for_low(self).await
     }
 
     #[inline]
+    #[allow(async_fn_in_trait)]
     async fn wait_for_rising_edge(&mut self) -> Result<(), Self::Error> {
         T::wait_for_rising_edge(self).await
     }
 
     #[inline]
+    #[allow(async_fn_in_trait)]
     async fn wait_for_falling_edge(&mut self) -> Result<(), Self::Error> {
         T::wait_for_falling_edge(self).await
     }
 
     #[inline]
+    #[allow(async_fn_in_trait)]
     async fn wait_for_any_edge(&mut self) -> Result<(), Self::Error> {
         T::wait_for_any_edge(self).await
     }

embedded-hal-async/src/i2c.rs

@@ -42,6 +42,7 @@ pub trait I2c<A: AddressMode = SevenBitAddress>: ErrorType {
     /// - `NMAK` = master no acknowledge
     /// - `SP` = stop condition
     #[inline]
+    #[allow(async_fn_in_trait)]
     async fn read(&mut self, address: A, read: &mut [u8]) -> Result<(), Self::Error> {
         self.transaction(address, &mut [Operation::Read(read)])
             .await
@@ -64,6 +65,7 @@ pub trait I2c<A: AddressMode = SevenBitAddress>: ErrorType {
     /// - `Bi` = ith byte of data
     /// - `SP` = stop condition
     #[inline]
+    #[allow(async_fn_in_trait)]
     async fn write(&mut self, address: A, write: &[u8]) -> Result<(), Self::Error> {
         self.transaction(address, &mut [Operation::Write(write)])
             .await
@@ -92,6 +94,7 @@ pub trait I2c<A: AddressMode = SevenBitAddress>: ErrorType {
     /// - `NMAK` = master no acknowledge
     /// - `SP` = stop condition
     #[inline]
+    #[allow(async_fn_in_trait)]
     async fn write_read(
         &mut self,
         address: A,
@@ -118,6 +121,7 @@ pub trait I2c<A: AddressMode = SevenBitAddress>: ErrorType {
     /// - `SAD+R/W` = slave address followed by bit 1 to indicate reading or 0 to indicate writing
     /// - `SR` = repeated start condition
     /// - `SP` = stop condition
+    #[allow(async_fn_in_trait)]
     async fn transaction(
         &mut self,
         address: A,
@@ -127,16 +131,19 @@ pub trait I2c<A: AddressMode = SevenBitAddress>: ErrorType {
 
 impl<A: AddressMode, T: I2c<A> + ?Sized> I2c<A> for &mut T {
     #[inline]
+    #[allow(async_fn_in_trait)]
     async fn read(&mut self, address: A, read: &mut [u8]) -> Result<(), Self::Error> {
         T::read(self, address, read).await
     }
 
     #[inline]
+    #[allow(async_fn_in_trait)]
     async fn write(&mut self, address: A, write: &[u8]) -> Result<(), Self::Error> {
         T::write(self, address, write).await
     }
 
     #[inline]
+    #[allow(async_fn_in_trait)]
     async fn write_read(
         &mut self,
         address: A,
@@ -147,6 +154,7 @@ impl<A: AddressMode, T: I2c<A> + ?Sized> I2c<A> for &mut T {
     }
 
     #[inline]
+    #[allow(async_fn_in_trait)]
     async fn transaction(
         &mut self,
         address: A,

embedded-hal-async/src/spi.rs

@@ -26,6 +26,7 @@ pub trait SpiDevice<Word: Copy + 'static = u8>: ErrorType {
     ///
     /// On bus errors the implementation should try to deassert CS.
     /// If an error occurs while deasserting CS the bus error should take priority as the return value.
+    #[allow(async_fn_in_trait)]
     async fn transaction(
         &mut self,
         operations: &mut [Operation<'_, Word>],
@@ -37,6 +38,7 @@ pub trait SpiDevice<Word: Copy + 'static = u8>: ErrorType {
     ///
     /// See also: [`SpiDevice::transaction`], [`SpiDevice::read`]
     #[inline]
+    #[allow(async_fn_in_trait)]
     async fn read(&mut self, buf: &mut [Word]) -> Result<(), Self::Error> {
         self.transaction(&mut [Operation::Read(buf)]).await
     }
@@ -47,6 +49,7 @@ pub trait SpiDevice<Word: Copy + 'static = u8>: ErrorType {
     ///
     /// See also: [`SpiDevice::transaction`], [`SpiDevice::write`]
     #[inline]
+    #[allow(async_fn_in_trait)]
     async fn write(&mut self, buf: &[Word]) -> Result<(), Self::Error> {
         self.transaction(&mut [Operation::Write(buf)]).await
     }
@@ -57,6 +60,7 @@ pub trait SpiDevice<Word: Copy + 'static = u8>: ErrorType {
     ///
     /// See also: [`SpiDevice::transaction`], [`SpiBus::transfer`]
     #[inline]
+    #[allow(async_fn_in_trait)]
     async fn transfer(&mut self, read: &mut [Word], write: &[Word]) -> Result<(), Self::Error> {
         self.transaction(&mut [Operation::Transfer(read, write)])
             .await
@@ -68,6 +72,7 @@ pub trait SpiDevice<Word: Copy + 'static = u8>: ErrorType {
     ///
     /// See also: [`SpiDevice::transaction`], [`SpiBus::transfer_in_place`]
     #[inline]
+    #[allow(async_fn_in_trait)]
     async fn transfer_in_place(&mut self, buf: &mut [Word]) -> Result<(), Self::Error> {
         self.transaction(&mut [Operation::TransferInPlace(buf)])
             .await
@@ -76,6 +81,7 @@ pub trait SpiDevice<Word: Copy + 'static = u8>: ErrorType {
 
 impl<Word: Copy + 'static, T: SpiDevice<Word> + ?Sized> SpiDevice<Word> for &mut T {
     #[inline]
+    #[allow(async_fn_in_trait)]
     async fn transaction(
         &mut self,
         operations: &mut [Operation<'_, Word>],
@@ -84,21 +90,25 @@ impl<Word: Copy + 'static, T: SpiDevice<Word> + ?Sized> SpiDevice<Word> for &mut
     }
 
     #[inline]
+    #[allow(async_fn_in_trait)]
     async fn read(&mut self, buf: &mut [Word]) -> Result<(), Self::Error> {
         T::read(self, buf).await
     }
 
     #[inline]
+    #[allow(async_fn_in_trait)]
     async fn write(&mut self, buf: &[Word]) -> Result<(), Self::Error> {
         T::write(self, buf).await
     }
 
     #[inline]
+    #[allow(async_fn_in_trait)]
     async fn transfer(&mut self, read: &mut [Word], write: &[Word]) -> Result<(), Self::Error> {
         T::transfer(self, read, write).await
     }
 
     #[inline]
+    #[allow(async_fn_in_trait)]
     async fn transfer_in_place(&mut self, buf: &mut [Word]) -> Result<(), Self::Error> {
         T::transfer_in_place(self, buf).await
     }
@@ -117,12 +127,14 @@ pub trait SpiBus<Word: 'static + Copy = u8>: ErrorType {
     ///
     /// Implementations are allowed to return before the operation is
     /// complete. See [the docs on embedded-hal][embedded_hal::spi] for details on flushing.
+    #[allow(async_fn_in_trait)]
     async fn read(&mut self, words: &mut [Word]) -> Result<(), Self::Error>;
 
     /// Write `words` to the slave, ignoring all the incoming words.
     ///
     /// Implementations are allowed to return before the operation is
     /// complete. See [the docs on embedded-hal][embedded_hal::spi] for details on flushing.
+    #[allow(async_fn_in_trait)]
     async fn write(&mut self, words: &[Word]) -> Result<(), Self::Error>;
 
     /// Write and read simultaneously. `write` is written to the slave on MOSI and
@@ -136,6 +148,7 @@ pub trait SpiBus<Word: 'static + Copy = u8>: ErrorType {
     ///
     /// Implementations are allowed to return before the operation is
     /// complete. See [the docs on embedded-hal][embedded_hal::spi] for details on flushing.
+    #[allow(async_fn_in_trait)]
     async fn transfer(&mut self, read: &mut [Word], write: &[Word]) -> Result<(), Self::Error>;
 
     /// Write and read simultaneously. The contents of `words` are
@@ -144,36 +157,43 @@ pub trait SpiBus<Word: 'static + Copy = u8>: ErrorType {
     ///
     /// Implementations are allowed to return before the operation is
     /// complete. See [the docs on embedded-hal][embedded_hal::spi] for details on flushing.
+    #[allow(async_fn_in_trait)]
     async fn transfer_in_place(&mut self, words: &mut [Word]) -> Result<(), Self::Error>;
 
     /// Wait until all operations have completed and the bus is idle.
     ///
     /// See [the docs on embedded-hal][embedded_hal::spi] for information on flushing.
+    #[allow(async_fn_in_trait)]
     async fn flush(&mut self) -> Result<(), Self::Error>;
 }
 
 impl<T: SpiBus<Word> + ?Sized, Word: 'static + Copy> SpiBus<Word> for &mut T {
     #[inline]
+    #[allow(async_fn_in_trait)]
     async fn read(&mut self, words: &mut [Word]) -> Result<(), Self::Error> {
         T::read(self, words).await
     }
 
     #[inline]
+    #[allow(async_fn_in_trait)]
     async fn write(&mut self, words: &[Word]) -> Result<(), Self::Error> {
         T::write(self, words).await
     }
 
     #[inline]
+    #[allow(async_fn_in_trait)]
     async fn transfer(&mut self, read: &mut [Word], write: &[Word]) -> Result<(), Self::Error> {
         T::transfer(self, read, write).await
     }
 
     #[inline]
+    #[allow(async_fn_in_trait)]
     async fn transfer_in_place(&mut self, words: &mut [Word]) -> Result<(), Self::Error> {
         T::transfer_in_place(self, words).await
     }
 
     #[inline]
+    #[allow(async_fn_in_trait)]
     async fn flush(&mut self) -> Result<(), Self::Error> {
         T::flush(self).await
     }

embedded-io-async/src/lib.rs

@@ -46,6 +46,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.
+    #[allow(async_fn_in_trait)]
     async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error>;
 
     /// Read the exact number of bytes required to fill `buf`.
@@ -55,6 +56,7 @@ 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.
+    #[allow(async_fn_in_trait)]
     async fn read_exact(&mut self, mut buf: &mut [u8]) -> Result<(), ReadExactError<Self::Error>> {
         while !buf.is_empty() {
             match self.read(buf).await {
@@ -82,6 +84,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.
+    #[allow(async_fn_in_trait)]
     async fn fill_buf(&mut self) -> 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`.
@@ -116,9 +119,11 @@ pub trait Write: ErrorType {
     /// the hardware with e.g. DMA.
     ///
     /// Implementations should document whether they're actually side-effect-free on cancel or not.
+    #[allow(async_fn_in_trait)]
     async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error>;
 
     /// Flush this output stream, ensuring that all intermediately buffered contents reach their destination.
+    #[allow(async_fn_in_trait)]
     async fn flush(&mut self) -> Result<(), Self::Error> {
         Ok(())
     }
@@ -130,6 +135,7 @@ 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.
+    #[allow(async_fn_in_trait)]
     async fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Error> {
         let mut buf = buf;
         while !buf.is_empty() {
@@ -148,28 +154,33 @@ 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.
+    #[allow(async_fn_in_trait)]
     async fn seek(&mut self, pos: SeekFrom) -> Result<u64, Self::Error>;
 
     /// Rewind to the beginning of a stream.
+    #[allow(async_fn_in_trait)]
     async fn rewind(&mut self) -> Result<(), Self::Error> {
         self.seek(SeekFrom::Start(0)).await?;
         Ok(())
     }
 
     /// Returns the current seek position from the start of the stream.
+    #[allow(async_fn_in_trait)]
     async fn stream_position(&mut self) -> Result<u64, Self::Error> {
         self.seek(SeekFrom::Current(0)).await
     }
 }
 
 impl<T: ?Sized + Read> Read for &mut T {
     #[inline]
+    #[allow(async_fn_in_trait)]
     async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
         T::read(self, buf).await
     }
 }
 
 impl<T: ?Sized + BufRead> BufRead for &mut T {
+    #[allow(async_fn_in_trait)]
     async fn fill_buf(&mut self) -> Result<&[u8], Self::Error> {
         T::fill_buf(self).await
     }
@@ -181,18 +192,21 @@ impl<T: ?Sized + BufRead> BufRead for &mut T {
 
 impl<T: ?Sized + Write> Write for &mut T {
     #[inline]
+    #[allow(async_fn_in_trait)]
     async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
         T::write(self, buf).await
     }
 
     #[inline]
+    #[allow(async_fn_in_trait)]
     async fn flush(&mut self) -> Result<(), Self::Error> {
         T::flush(self).await
     }
 }
 
 impl<T: ?Sized + Seek> Seek for &mut T {
     #[inline]
+    #[allow(async_fn_in_trait)]
     async fn seek(&mut self, pos: SeekFrom) -> Result<u64, Self::Error> {
         T::seek(self, pos).await
     }