Remove nightly and unstable-traits features in preparation for 1.75.

4 files changed, 68 insertions, 63 deletions

diff --git a/embassy-sync/Cargo.toml b/embassy-sync/Cargo.toml
index ffcd13d9f..6588406a1 100644
--- a/embassy-sync/Cargo.toml
+++ b/embassy-sync/Cargo.toml
@@ -16,14 +16,9 @@ categories = [
 [package.metadata.embassy_docs]
 src_base = "https://github.com/embassy-rs/embassy/blob/embassy-sync-v$VERSION/embassy-sync/src/"
 src_base_git = "https://github.com/embassy-rs/embassy/blob/$COMMIT/embassy-sync/src/"
-features = ["nightly"]
 target = "thumbv7em-none-eabi"
 
-[package.metadata.docs.rs]
-features = ["nightly"]
-
 [features]
-nightly = ["dep:embedded-io-async"]
 std = []
 turbowakers = []
 
@@ -35,7 +30,7 @@ futures-util = { version = "0.3.17", default-features = false }
 critical-section = "1.1"
 heapless = "0.8"
 cfg-if = "1.0.0"
-embedded-io-async = { version = "0.6.1", optional = true }
+embedded-io-async = { version = "0.6.1" }
 
 [dev-dependencies]
 futures-executor = { version = "0.3.17", features = [ "thread-pool" ] }
diff --git a/embassy-sync/build.rs b/embassy-sync/build.rs
index 6fe82b44f..0a796b881 100644
--- a/embassy-sync/build.rs
+++ b/embassy-sync/build.rs
@@ -1,6 +1,21 @@
 use std::env;
+use std::ffi::OsString;
+use std::process::Command;
 
 fn main() {
+    println!("cargo:rerun-if-changed=build.rs");
+
+    let rustc = env::var_os("RUSTC").unwrap_or_else(|| OsString::from("rustc"));
+
+    let output = Command::new(rustc)
+        .arg("--version")
+        .output()
+        .expect("failed to run `rustc --version`");
+
+    if String::from_utf8_lossy(&output.stdout).contains("nightly") {
+        println!("cargo:rustc-cfg=nightly");
+    }
+
     let target = env::var("TARGET").unwrap();
 
     if target.starts_with("thumbv6m-") {
diff --git a/embassy-sync/src/lib.rs b/embassy-sync/src/lib.rs
index 3ffcb9135..b0ccfde57 100644
--- a/embassy-sync/src/lib.rs
+++ b/embassy-sync/src/lib.rs
@@ -1,6 +1,7 @@
 #![cfg_attr(not(any(feature = "std", feature = "wasm")), no_std)]
-#![cfg_attr(feature = "nightly", feature(async_fn_in_trait, impl_trait_projections))]
-#![cfg_attr(feature = "nightly", allow(stable_features, unknown_lints, async_fn_in_trait))]
+#![cfg_attr(nightly, feature(async_fn_in_trait, impl_trait_projections))]
+#![cfg_attr(nightly, allow(stable_features, unknown_lints))]
+#![allow(async_fn_in_trait)]
 #![allow(clippy::new_without_default)]
 #![doc = include_str!("../README.md")]
 #![warn(missing_docs)]
diff --git a/embassy-sync/src/pipe.rs b/embassy-sync/src/pipe.rs
index ec0cbbf2a..42fe8ebd0 100644
--- a/embassy-sync/src/pipe.rs
+++ b/embassy-sync/src/pipe.rs
@@ -1,6 +1,7 @@
 //! Async byte stream pipe.
 
 use core::cell::{RefCell, UnsafeCell};
+use core::convert::Infallible;
 use core::future::Future;
 use core::ops::Range;
 use core::pin::Pin;
@@ -457,84 +458,77 @@ where
     }
 }
 
-#[cfg(feature = "nightly")]
-mod io_impls {
-    use core::convert::Infallible;
+impl<M: RawMutex, const N: usize> embedded_io_async::ErrorType for Pipe<M, N> {
+    type Error = Infallible;
+}
 
-    use super::*;
+impl<M: RawMutex, const N: usize> embedded_io_async::Read for Pipe<M, N> {
+    async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
+        Ok(Pipe::read(self, buf).await)
+    }
+}
 
-    impl<M: RawMutex, const N: usize> embedded_io_async::ErrorType for Pipe<M, N> {
-        type Error = Infallible;
+impl<M: RawMutex, const N: usize> embedded_io_async::Write for Pipe<M, N> {
+    async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
+        Ok(Pipe::write(self, buf).await)
     }
 
-    impl<M: RawMutex, const N: usize> embedded_io_async::Read for Pipe<M, N> {
-        async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
-            Ok(Pipe::read(self, buf).await)
-        }
+    async fn flush(&mut self) -> Result<(), Self::Error> {
+        Ok(())
     }
+}
 
-    impl<M: RawMutex, const N: usize> embedded_io_async::Write for Pipe<M, N> {
-        async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
-            Ok(Pipe::write(self, buf).await)
-        }
+impl<M: RawMutex, const N: usize> embedded_io_async::ErrorType for &Pipe<M, N> {
+    type Error = Infallible;
+}
 
-        async fn flush(&mut self) -> Result<(), Self::Error> {
-            Ok(())
-        }
+impl<M: RawMutex, const N: usize> embedded_io_async::Read for &Pipe<M, N> {
+    async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
+        Ok(Pipe::read(self, buf).await)
     }
+}
 
-    impl<M: RawMutex, const N: usize> embedded_io_async::ErrorType for &Pipe<M, N> {
-        type Error = Infallible;
+impl<M: RawMutex, const N: usize> embedded_io_async::Write for &Pipe<M, N> {
+    async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
+        Ok(Pipe::write(self, buf).await)
     }
 
-    impl<M: RawMutex, const N: usize> embedded_io_async::Read for &Pipe<M, N> {
-        async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
-            Ok(Pipe::read(self, buf).await)
-        }
+    async fn flush(&mut self) -> Result<(), Self::Error> {
+        Ok(())
     }
+}
 
-    impl<M: RawMutex, const N: usize> embedded_io_async::Write for &Pipe<M, N> {
-        async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
-            Ok(Pipe::write(self, buf).await)
-        }
+impl<M: RawMutex, const N: usize> embedded_io_async::ErrorType for Reader<'_, M, N> {
+    type Error = Infallible;
+}
 
-        async fn flush(&mut self) -> Result<(), Self::Error> {
-            Ok(())
-        }
+impl<M: RawMutex, const N: usize> embedded_io_async::Read for Reader<'_, M, N> {
+    async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
+        Ok(Reader::read(self, buf).await)
     }
+}
 
-    impl<M: RawMutex, const N: usize> embedded_io_async::ErrorType for Reader<'_, M, N> {
-        type Error = Infallible;
+impl<M: RawMutex, const N: usize> embedded_io_async::BufRead for Reader<'_, M, N> {
+    async fn fill_buf(&mut self) -> Result<&[u8], Self::Error> {
+        Ok(Reader::fill_buf(self).await)
     }
 
-    impl<M: RawMutex, const N: usize> embedded_io_async::Read for Reader<'_, M, N> {
-        async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
-            Ok(Reader::read(self, buf).await)
-        }
+    fn consume(&mut self, amt: usize) {
+        Reader::consume(self, amt)
     }
+}
 
-    impl<M: RawMutex, const N: usize> embedded_io_async::BufRead for Reader<'_, M, N> {
-        async fn fill_buf(&mut self) -> Result<&[u8], Self::Error> {
-            Ok(Reader::fill_buf(self).await)
-        }
-
-        fn consume(&mut self, amt: usize) {
-            Reader::consume(self, amt)
-        }
-    }
+impl<M: RawMutex, const N: usize> embedded_io_async::ErrorType for Writer<'_, M, N> {
+    type Error = Infallible;
+}
 
-    impl<M: RawMutex, const N: usize> embedded_io_async::ErrorType for Writer<'_, M, N> {
-        type Error = Infallible;
+impl<M: RawMutex, const N: usize> embedded_io_async::Write for Writer<'_, M, N> {
+    async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
+        Ok(Writer::write(self, buf).await)
     }
 
-    impl<M: RawMutex, const N: usize> embedded_io_async::Write for Writer<'_, M, N> {
-        async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
-            Ok(Writer::write(self, buf).await)
-        }
-
-        async fn flush(&mut self) -> Result<(), Self::Error> {
-            Ok(())
-        }
+    async fn flush(&mut self) -> Result<(), Self::Error> {
+        Ok(())
     }
 }