lint: Gate internal-only traits to when they are really used

This is one way of dealing with warnings shown otherwise.

Author: chrysn

src/helpers.rs

@@ -61,49 +61,55 @@ impl PointerToCStr for *const i8 {
     }
 }
 
-/// Trait that eases conversions from a char slice (no matter the signedness, they are used
-/// inconsistently in RIOT) to a CStr. The result is often used with `?.to_str().ok()?`.
-pub(crate) trait SliceToCStr {
-    /// Cast self around until it is suitable input to [`core::ffi::CStr::from_bytes_until_nul()`],
-    /// and run that function.
-    ///
-    /// Note that while "the slice until any null byte" could be safely used in Rust (as a slice or
-    /// even a str), its presence in C practically always indicates an error, also because that
-    /// data wouldn't be usable by other C code using its string conventions.
-    ///
-    /// It is using a local error type because while the semantics of `from_bytes_until_nul` are
-    /// the right ones considering how this is used on C fields that are treated with `strlen()`
-    /// etc., that function is not stable yet and emulated.
-    fn to_cstr(&self) -> Result<&core::ffi::CStr, FromBytesUntilNulError>;
-}
+// Gated because it is only used there -- expand as needed.
+#[cfg(riot_module_vfs)]
+mod slice_to_cstr {
+    /// Trait that eases conversions from a char slice (no matter the signedness, they are used
+    /// inconsistently in RIOT) to a CStr. The result is often used with `?.to_str().ok()?`.
+    pub(crate) trait SliceToCStr {
+        /// Cast self around until it is suitable input to [`core::ffi::CStr::from_bytes_until_nul()`],
+        /// and run that function.
+        ///
+        /// Note that while "the slice until any null byte" could be safely used in Rust (as a slice or
+        /// even a str), its presence in C practically always indicates an error, also because that
+        /// data wouldn't be usable by other C code using its string conventions.
+        ///
+        /// It is using a local error type because while the semantics of `from_bytes_until_nul` are
+        /// the right ones considering how this is used on C fields that are treated with `strlen()`
+        /// etc., that function is not stable yet and emulated.
+        fn to_cstr(&self) -> Result<&core::ffi::CStr, FromBytesUntilNulError>;
+    }
 
-// Unlike in the from_ptr case, this is consistently taking u8, so only the i8 case gets casting.
+    // Unlike in the from_ptr case, this is consistently taking u8, so only the i8 case gets casting.
 
-impl SliceToCStr for [u8] {
-    fn to_cstr(&self) -> Result<&core::ffi::CStr, FromBytesUntilNulError> {
-        // Emulate from_bytes_until_null
-        let index = self
-            .iter()
-            .position(|&c| c == 0)
-            .ok_or(FromBytesUntilNulError {})?;
+    impl SliceToCStr for [u8] {
+        fn to_cstr(&self) -> Result<&core::ffi::CStr, FromBytesUntilNulError> {
+            // Emulate from_bytes_until_null
+            let index = self
+                .iter()
+                .position(|&c| c == 0)
+                .ok_or(FromBytesUntilNulError {})?;
 
-        core::ffi::CStr::from_bytes_with_nul(&self[..index + 1])
-            // Actually the error is unreachable
-            .map_err(|_| FromBytesUntilNulError {})
+            core::ffi::CStr::from_bytes_with_nul(&self[..index + 1])
+                // Actually the error is unreachable
+                .map_err(|_| FromBytesUntilNulError {})
+        }
     }
-}
 
-impl SliceToCStr for [i8] {
-    fn to_cstr(&self) -> Result<&core::ffi::CStr, FromBytesUntilNulError> {
-        let s: &[u8] = unsafe { core::mem::transmute(self) };
-        s.to_cstr()
+    impl SliceToCStr for [i8] {
+        fn to_cstr(&self) -> Result<&core::ffi::CStr, FromBytesUntilNulError> {
+            let s: &[u8] = unsafe { core::mem::transmute(self) };
+            s.to_cstr()
+        }
     }
-}
 
-/// Error from [SliceToCStr::to_cstr].
-///
-/// This will become [core::ffi:FromBytesUntilNulError] once that's stable, and may be changed
-/// without a breaking release even though it's technically a breaking change. (At this point, that
-/// type will be `pub use`d here and deprecated).
-#[derive(Debug)]
-pub struct FromBytesUntilNulError {}
+    /// Error from [SliceToCStr::to_cstr].
+    ///
+    /// This will become [core::ffi:FromBytesUntilNulError] once that's stable, and may be changed
+    /// without a breaking release even though it's technically a breaking change. (At this point, that
+    /// type will be `pub use`d here and deprecated).
+    #[derive(Debug)]
+    pub struct FromBytesUntilNulError {}
+}
+#[cfg(riot_module_vfs)]
+pub use slice_to_cstr::*;

src/lib.rs

@@ -184,4 +184,10 @@ pub mod led;
 #[cfg(riot_module_auto_init)]
 pub mod auto_init;
 
+// Gated like socket_embedded_nal_async_udp as it is only used there -- expand as needed.
+#[cfg(all(
+    riot_module_sock_udp,
+    riot_module_sock_aux_local,
+    feature = "with_embedded_nal_async"
+))]
 mod async_helpers;