Make RawSmallVec (and its fields) public only under feature = "internals". (v2)

Cargo.toml

@@ -18,6 +18,7 @@ std = []
 specialization = []
 may_dangle = []
 serde = ["dep:serde_core"]
+internals = []
 
 [dependencies]
 bytes = { version = "1", optional = true, default-features = false }

src/lib.rs

@@ -62,6 +62,7 @@ pub extern crate alloc;
 #[cfg(any(test, feature = "std"))]
 extern crate std;
 
+mod rawsmallvec;
 #[cfg(test)]
 mod tests;
 
@@ -95,6 +96,11 @@ use serde_core::{
 #[cfg(feature = "std")]
 use std::io;
 
+#[cfg(feature = "internals")]
+pub use rawsmallvec::RawSmallVec;
+#[cfg(not(feature = "internals"))]
+use rawsmallvec::RawSmallVec;
+
 /// Error type for APIs with fallible heap allocation
 #[derive(Debug)]
 pub enum CollectionAllocErr {
@@ -114,18 +120,6 @@ impl core::fmt::Display for CollectionAllocErr {
 
 impl core::error::Error for CollectionAllocErr {}
 
-/// Either a stack array with `length <= N` or a heap array
-/// whose pointer and capacity are stored here.
-///
-/// We store a `NonNull<T>` instead of a `*mut T`, so that
-/// niche-optimization can be performed and the type is covariant
-/// with respect to `T`.
-#[repr(C)]
-pub union RawSmallVec<T, const N: usize> {
-    inline: ManuallyDrop<MaybeUninit<[T; N]>>,
-    heap: (NonNull<T>, usize),
-}
-
 #[inline]
 fn infallible<T>(result: Result<T, CollectionAllocErr>) -> T {
     match result {

src/rawsmallvec.rs

@@ -0,0 +1,13 @@
+use core::mem::{ManuallyDrop, MaybeUninit};
+use core::ptr::NonNull;
+
+/// Either a stack array with `length <= N` or a heap array
+/// whose pointer and capacity are stored here.
+///
+/// We store a `NonNull<T>` instead of a `*mut T` so that type is covariant
+/// with respect to `T`, and since the heap pointer is never null.
+#[repr(C)]
+pub union RawSmallVec<T, const N: usize> {
+    pub inline: ManuallyDrop<MaybeUninit<[T; N]>>,
+    pub heap: (NonNull<T>, usize),
+}