Make embassy-net nightly-only.

It's useless without async traits, so juggling the `nightly` feature
around is not worth the pain.

3 files changed, 127 insertions, 136 deletions

diff --git a/embassy-net/src/lib.rs b/embassy-net/src/lib.rs
index ded841909..18dc1ef61 100644
--- a/embassy-net/src/lib.rs
+++ b/embassy-net/src/lib.rs
@@ -1,9 +1,6 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 #![allow(clippy::new_without_default)]
-#![cfg_attr(
-    feature = "nightly",
-    feature(generic_associated_types, type_alias_impl_trait)
-)]
+#![feature(generic_associated_types, type_alias_impl_trait)]
 
 // This mod MUST go first, so that the others see its macros.
 pub(crate) mod fmt;
diff --git a/embassy-net/src/tcp/mod.rs b/embassy-net/src/tcp.rs
index 425e6acbc..c18651b93 100644
--- a/embassy-net/src/tcp/mod.rs
+++ b/embassy-net/src/tcp.rs
@@ -1,15 +1,14 @@
+use core::future::Future;
 use core::marker::PhantomData;
 use core::mem;
 use core::task::Poll;
+use futures::future::poll_fn;
 use smoltcp::iface::{Context as SmolContext, SocketHandle};
 use smoltcp::socket::TcpSocket as SyncTcpSocket;
 use smoltcp::socket::{TcpSocketBuffer, TcpState};
 use smoltcp::time::Duration;
 use smoltcp::wire::IpEndpoint;
 
-#[cfg(feature = "nightly")]
-mod io_impl;
-
 use super::stack::Stack;
 
 #[derive(PartialEq, Eq, Clone, Copy, Debug)]
@@ -221,10 +220,134 @@ impl<'d> embedded_io::Io for TcpSocket<'d> {
     type Error = Error;
 }
 
+impl<'d> embedded_io::asynch::Read for TcpSocket<'d> {
+    type ReadFuture<'a> = impl Future<Output = Result<usize, Self::Error>>
+    where
+        Self: 'a;
+
+    fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> Self::ReadFuture<'a> {
+        poll_fn(move |cx| {
+            // CAUTION: smoltcp semantics around EOF are different to what you'd expect
+            // from posix-like IO, so we have to tweak things here.
+            with_socket(self.handle, |s, _| match s.recv_slice(buf) {
+                // No data ready
+                Ok(0) => {
+                    s.register_recv_waker(cx.waker());
+                    Poll::Pending
+                }
+                // Data ready!
+                Ok(n) => Poll::Ready(Ok(n)),
+                // EOF
+                Err(smoltcp::Error::Finished) => Poll::Ready(Ok(0)),
+                // Connection reset. TODO: this can also be timeouts etc, investigate.
+                Err(smoltcp::Error::Illegal) => Poll::Ready(Err(Error::ConnectionReset)),
+                // smoltcp returns no errors other than the above.
+                Err(_) => unreachable!(),
+            })
+        })
+    }
+}
+
+impl<'d> embedded_io::asynch::Write for TcpSocket<'d> {
+    type WriteFuture<'a> = impl Future<Output = Result<usize, Self::Error>>
+    where
+        Self: 'a;
+
+    fn write<'a>(&'a mut self, buf: &'a [u8]) -> Self::WriteFuture<'a> {
+        poll_fn(move |cx| {
+            with_socket(self.handle, |s, _| match s.send_slice(buf) {
+                // Not ready to send (no space in the tx buffer)
+                Ok(0) => {
+                    s.register_send_waker(cx.waker());
+                    Poll::Pending
+                }
+                // Some data sent
+                Ok(n) => Poll::Ready(Ok(n)),
+                // Connection reset. TODO: this can also be timeouts etc, investigate.
+                Err(smoltcp::Error::Illegal) => Poll::Ready(Err(Error::ConnectionReset)),
+                // smoltcp returns no errors other than the above.
+                Err(_) => unreachable!(),
+            })
+        })
+    }
+
+    type FlushFuture<'a> = impl Future<Output = Result<(), Self::Error>>
+    where
+        Self: 'a;
+
+    fn flush<'a>(&'a mut self) -> Self::FlushFuture<'a> {
+        poll_fn(move |_| {
+            Poll::Ready(Ok(())) // TODO: Is there a better implementation for this?
+        })
+    }
+}
+
 impl<'d> embedded_io::Io for TcpReader<'d> {
     type Error = Error;
 }
 
+impl<'d> embedded_io::asynch::Read for TcpReader<'d> {
+    type ReadFuture<'a> = impl Future<Output = Result<usize, Self::Error>>
+    where
+        Self: 'a;
+
+    fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> Self::ReadFuture<'a> {
+        poll_fn(move |cx| {
+            // CAUTION: smoltcp semantics around EOF are different to what you'd expect
+            // from posix-like IO, so we have to tweak things here.
+            with_socket(self.handle, |s, _| match s.recv_slice(buf) {
+                // No data ready
+                Ok(0) => {
+                    s.register_recv_waker(cx.waker());
+                    Poll::Pending
+                }
+                // Data ready!
+                Ok(n) => Poll::Ready(Ok(n)),
+                // EOF
+                Err(smoltcp::Error::Finished) => Poll::Ready(Ok(0)),
+                // Connection reset. TODO: this can also be timeouts etc, investigate.
+                Err(smoltcp::Error::Illegal) => Poll::Ready(Err(Error::ConnectionReset)),
+                // smoltcp returns no errors other than the above.
+                Err(_) => unreachable!(),
+            })
+        })
+    }
+}
+
 impl<'d> embedded_io::Io for TcpWriter<'d> {
     type Error = Error;
 }
+
+impl<'d> embedded_io::asynch::Write for TcpWriter<'d> {
+    type WriteFuture<'a> = impl Future<Output = Result<usize, Self::Error>>
+    where
+        Self: 'a;
+
+    fn write<'a>(&'a mut self, buf: &'a [u8]) -> Self::WriteFuture<'a> {
+        poll_fn(move |cx| {
+            with_socket(self.handle, |s, _| match s.send_slice(buf) {
+                // Not ready to send (no space in the tx buffer)
+                Ok(0) => {
+                    s.register_send_waker(cx.waker());
+                    Poll::Pending
+                }
+                // Some data sent
+                Ok(n) => Poll::Ready(Ok(n)),
+                // Connection reset. TODO: this can also be timeouts etc, investigate.
+                Err(smoltcp::Error::Illegal) => Poll::Ready(Err(Error::ConnectionReset)),
+                // smoltcp returns no errors other than the above.
+                Err(_) => unreachable!(),
+            })
+        })
+    }
+
+    type FlushFuture<'a> = impl Future<Output = Result<(), Self::Error>>
+    where
+        Self: 'a;
+
+    fn flush<'a>(&'a mut self) -> Self::FlushFuture<'a> {
+        poll_fn(move |_| {
+            Poll::Ready(Ok(())) // TODO: Is there a better implementation for this?
+        })
+    }
+}
diff --git a/embassy-net/src/tcp/io_impl.rs b/embassy-net/src/tcp/io_impl.rs
deleted file mode 100644
index b30c920b8..000000000
--- a/embassy-net/src/tcp/io_impl.rs
+++ /dev/null
@@ -1,129 +0,0 @@
-use core::future::Future;
-use core::task::Poll;
-use futures::future::poll_fn;
-
-use super::{with_socket, Error, TcpReader, TcpSocket, TcpWriter};
-
-impl<'d> embedded_io::asynch::Read for TcpSocket<'d> {
-    type ReadFuture<'a> = impl Future<Output = Result<usize, Self::Error>>
-    where
-        Self: 'a;
-
-    fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> Self::ReadFuture<'a> {
-        poll_fn(move |cx| {
-            // CAUTION: smoltcp semantics around EOF are different to what you'd expect
-            // from posix-like IO, so we have to tweak things here.
-            with_socket(self.handle, |s, _| match s.recv_slice(buf) {
-                // No data ready
-                Ok(0) => {
-                    s.register_recv_waker(cx.waker());
-                    Poll::Pending
-                }
-                // Data ready!
-                Ok(n) => Poll::Ready(Ok(n)),
-                // EOF
-                Err(smoltcp::Error::Finished) => Poll::Ready(Ok(0)),
-                // Connection reset. TODO: this can also be timeouts etc, investigate.
-                Err(smoltcp::Error::Illegal) => Poll::Ready(Err(Error::ConnectionReset)),
-                // smoltcp returns no errors other than the above.
-                Err(_) => unreachable!(),
-            })
-        })
-    }
-}
-
-impl<'d> embedded_io::asynch::Write for TcpSocket<'d> {
-    type WriteFuture<'a> = impl Future<Output = Result<usize, Self::Error>>
-    where
-        Self: 'a;
-
-    fn write<'a>(&'a mut self, buf: &'a [u8]) -> Self::WriteFuture<'a> {
-        poll_fn(move |cx| {
-            with_socket(self.handle, |s, _| match s.send_slice(buf) {
-                // Not ready to send (no space in the tx buffer)
-                Ok(0) => {
-                    s.register_send_waker(cx.waker());
-                    Poll::Pending
-                }
-                // Some data sent
-                Ok(n) => Poll::Ready(Ok(n)),
-                // Connection reset. TODO: this can also be timeouts etc, investigate.
-                Err(smoltcp::Error::Illegal) => Poll::Ready(Err(Error::ConnectionReset)),
-                // smoltcp returns no errors other than the above.
-                Err(_) => unreachable!(),
-            })
-        })
-    }
-
-    type FlushFuture<'a> = impl Future<Output = Result<(), Self::Error>>
-    where
-        Self: 'a;
-
-    fn flush<'a>(&'a mut self) -> Self::FlushFuture<'a> {
-        poll_fn(move |_| {
-            Poll::Ready(Ok(())) // TODO: Is there a better implementation for this?
-        })
-    }
-}
-
-impl<'d> embedded_io::asynch::Read for TcpReader<'d> {
-    type ReadFuture<'a> = impl Future<Output = Result<usize, Self::Error>>
-    where
-        Self: 'a;
-
-    fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> Self::ReadFuture<'a> {
-        poll_fn(move |cx| {
-            // CAUTION: smoltcp semantics around EOF are different to what you'd expect
-            // from posix-like IO, so we have to tweak things here.
-            with_socket(self.handle, |s, _| match s.recv_slice(buf) {
-                // No data ready
-                Ok(0) => {
-                    s.register_recv_waker(cx.waker());
-                    Poll::Pending
-                }
-                // Data ready!
-                Ok(n) => Poll::Ready(Ok(n)),
-                // EOF
-                Err(smoltcp::Error::Finished) => Poll::Ready(Ok(0)),
-                // Connection reset. TODO: this can also be timeouts etc, investigate.
-                Err(smoltcp::Error::Illegal) => Poll::Ready(Err(Error::ConnectionReset)),
-                // smoltcp returns no errors other than the above.
-                Err(_) => unreachable!(),
-            })
-        })
-    }
-}
-
-impl<'d> embedded_io::asynch::Write for TcpWriter<'d> {
-    type WriteFuture<'a> = impl Future<Output = Result<usize, Self::Error>>
-    where
-        Self: 'a;
-
-    fn write<'a>(&'a mut self, buf: &'a [u8]) -> Self::WriteFuture<'a> {
-        poll_fn(move |cx| {
-            with_socket(self.handle, |s, _| match s.send_slice(buf) {
-                // Not ready to send (no space in the tx buffer)
-                Ok(0) => {
-                    s.register_send_waker(cx.waker());
-                    Poll::Pending
-                }
-                // Some data sent
-                Ok(n) => Poll::Ready(Ok(n)),
-                // Connection reset. TODO: this can also be timeouts etc, investigate.
-                Err(smoltcp::Error::Illegal) => Poll::Ready(Err(Error::ConnectionReset)),
-                // smoltcp returns no errors other than the above.
-                Err(_) => unreachable!(),
-            })
-        })
-    }
-
-    type FlushFuture<'a> = impl Future<Output = Result<(), Self::Error>>
-    where
-        Self: 'a;
-
-    fn flush<'a>(&'a mut self) -> Self::FlushFuture<'a> {
-        poll_fn(move |_| {
-            Poll::Ready(Ok(())) // TODO: Is there a better implementation for this?
-        })
-    }
-}