Merge branch 'main' into schema-for-cow

Author: jamesmunns

source/postcard-schema/src/impls/builtins_alloc.rs

@@ -4,25 +4,35 @@ use crate::{schema::DataModelType, Schema};
 
 extern crate alloc;
 
+#[cfg_attr(docsrs, doc(cfg(any(feature = "alloc", feature = "use-std"))))]
 impl<T: Schema> Schema for alloc::vec::Vec<T> {
     const SCHEMA: &'static DataModelType = &DataModelType::Seq(T::SCHEMA);
 }
 
+#[cfg_attr(docsrs, doc(cfg(any(feature = "alloc", feature = "use-std"))))]
 impl Schema for alloc::string::String {
     const SCHEMA: &'static DataModelType = &DataModelType::String;
 }
 
+#[cfg_attr(docsrs, doc(cfg(any(feature = "alloc", feature = "use-std"))))]
 impl<K: Schema, V: Schema> Schema for alloc::collections::BTreeMap<K, V> {
     const SCHEMA: &'static DataModelType = &DataModelType::Map {
         key: K::SCHEMA,
         val: V::SCHEMA,
     };
 }
 
+#[cfg_attr(docsrs, doc(cfg(any(feature = "alloc", feature = "use-std"))))]
 impl<K: Schema> Schema for alloc::collections::BTreeSet<K> {
     const SCHEMA: &'static DataModelType = &DataModelType::Seq(K::SCHEMA);
 }
 
+#[cfg_attr(docsrs, doc(cfg(any(feature = "alloc", feature = "use-std"))))]
+impl<T: Schema> Schema for alloc::boxed::Box<T> {
+    const SCHEMA: &'static DataModelType = T::SCHEMA;
+}
+
+#[cfg_attr(docsrs, doc(cfg(any(feature = "alloc", feature = "use-std"))))]
 impl<T: ?Sized + Schema + alloc::borrow::ToOwned> Schema for alloc::borrow::Cow<'_, T> {
     const SCHEMA: &'static DataModelType = T::SCHEMA;
 }

source/postcard-schema/src/impls/builtins_std.rs

@@ -43,6 +43,11 @@ impl<K: Schema> Schema for std::collections::BTreeSet<K> {
     const SCHEMA: &'static DataModelType = &DataModelType::Seq(K::SCHEMA);
 }
 
+#[cfg_attr(docsrs, doc(cfg(any(feature = "alloc", feature = "use-std"))))]
+impl<T: Schema> Schema for std::boxed::Box<T> {
+    const SCHEMA: &'static DataModelType = T::SCHEMA;
+}
+
 #[cfg_attr(docsrs, doc(cfg(any(feature = "alloc", feature = "use-std"))))]
 impl<T: ?Sized + Schema + std::borrow::ToOwned> Schema for std::borrow::Cow<'_, T> {
     const SCHEMA: &'static DataModelType = T::SCHEMA;

source/postcard/src/de/flavors.rs

@@ -138,9 +138,10 @@ pub struct Slice<'de> {
 impl<'de> Slice<'de> {
     /// Create a new [Slice] from the given buffer
     pub fn new(sli: &'de [u8]) -> Self {
+        let range = sli.as_ptr_range();
         Self {
-            cursor: sli.as_ptr(),
-            end: unsafe { sli.as_ptr().add(sli.len()) },
+            cursor: range.start,
+            end: range.end,
             _pl: PhantomData,
         }
     }
@@ -155,6 +156,8 @@ impl<'de> Flavor<'de> for Slice<'de> {
         if self.cursor == self.end {
             Err(Error::DeserializeUnexpectedEnd)
         } else {
+            // SAFETY: `self.cursor` is in-bounds and won't be incremented past `self.end` as we
+            // have checked above.
             unsafe {
                 let res = Ok(*self.cursor);
                 self.cursor = self.cursor.add(1);
@@ -174,6 +177,8 @@ impl<'de> Flavor<'de> for Slice<'de> {
         if remain < ct {
             Err(Error::DeserializeUnexpectedEnd)
         } else {
+            // SAFETY: `self.cursor` is valid for `ct` elements and won't be incremented past `self.end` as we
+            // have checked above.
             unsafe {
                 let sli = core::slice::from_raw_parts(self.cursor, ct);
                 self.cursor = self.cursor.add(ct);
@@ -185,6 +190,7 @@ impl<'de> Flavor<'de> for Slice<'de> {
     /// Return the remaining (unused) bytes in the Deserializer
     fn finalize(self) -> Result<&'de [u8]> {
         let remain = (self.end as usize) - (self.cursor as usize);
+        // SAFETY: `self.cursor` is valid for `remain` elements
         unsafe { Ok(core::slice::from_raw_parts(self.cursor, remain)) }
     }
 }
@@ -207,9 +213,10 @@ pub mod io {
 
     impl<'de> SlidingBuffer<'de> {
         pub fn new(sli: &'de mut [u8]) -> Self {
+            let range = sli.as_mut_ptr_range();
             Self {
-                cursor: sli.as_mut_ptr(),
-                end: unsafe { sli.as_ptr().add(sli.len()) },
+                cursor: range.start,
+                end: range.end,
                 _pl: PhantomData,
             }
         }
@@ -225,6 +232,8 @@ pub mod io {
             let buff = if remain < ct {
                 return Err(Error::DeserializeUnexpectedEnd);
             } else {
+                // SAFETY: `self.cursor` is valid for `ct` elements and won't be incremented
+                // past `self.end` as we have checked above.
                 unsafe {
                     let sli = core::slice::from_raw_parts_mut(self.cursor, ct);
                     self.cursor = self.cursor.add(ct);
@@ -237,6 +246,7 @@ pub mod io {
 
         fn complete(self) -> Result<&'de mut [u8]> {
             let remain = (self.end as usize) - (self.cursor as usize);
+            // SAFETY: `self.cursor` is valid for `remain` elements
             unsafe { Ok(core::slice::from_raw_parts_mut(self.cursor, remain)) }
         }
     }

source/postcard/src/ser/flavors.rs

@@ -146,11 +146,11 @@ pub struct Slice<'a> {
 impl<'a> Slice<'a> {
     /// Create a new `Slice` flavor from a given backing buffer
     pub fn new(buf: &'a mut [u8]) -> Self {
-        let ptr = buf.as_mut_ptr();
+        let ptr = buf.as_mut_ptr_range();
         Slice {
-            start: ptr,
-            cursor: ptr,
-            end: unsafe { ptr.add(buf.len()) },
+            start: ptr.start,
+            cursor: ptr.start,
+            end: ptr.end,
             _pl: PhantomData,
         }
     }
@@ -164,6 +164,8 @@ impl<'a> Flavor for Slice<'a> {
         if self.cursor == self.end {
             Err(Error::SerializeBufferFull)
         } else {
+            // SAFETY: `self.cursor` is in-bounds and won't be incremented past `self.end` as we
+            // have checked above.
             unsafe {
                 self.cursor.write(b);
                 self.cursor = self.cursor.add(1);
@@ -179,6 +181,8 @@ impl<'a> Flavor for Slice<'a> {
         if blen > remain {
             Err(Error::SerializeBufferFull)
         } else {
+            // SAFETY: `self.cursor` is in-bounds for `blen` elements and won't be incremented past
+            // `self.end` as we have checked above.
             unsafe {
                 core::ptr::copy_nonoverlapping(b.as_ptr(), self.cursor, blen);
                 self.cursor = self.cursor.add(blen);
@@ -189,6 +193,7 @@ impl<'a> Flavor for Slice<'a> {
 
     fn finalize(self) -> Result<Self::Output> {
         let used = (self.cursor as usize) - (self.start as usize);
+        // SAFETY: `self.cursor` is in-bounds for `used` elements
         let sli = unsafe { core::slice::from_raw_parts_mut(self.start, used) };
         Ok(sli)
     }
@@ -200,6 +205,7 @@ impl Index<usize> for Slice<'_> {
     fn index(&self, idx: usize) -> &u8 {
         let len = (self.end as usize) - (self.start as usize);
         assert!(idx < len);
+        // SAFETY: `self.start` is in-bounds at `idx`
         unsafe { &*self.start.add(idx) }
     }
 }
@@ -208,6 +214,7 @@ impl IndexMut<usize> for Slice<'_> {
     fn index_mut(&mut self, idx: usize) -> &mut u8 {
         let len = (self.end as usize) - (self.start as usize);
         assert!(idx < len);
+        // SAFETY: `self.start` is in-bounds at `idx`
         unsafe { &mut *self.start.add(idx) }
     }
 }