Implement BorshSerialize/BoshDeserialize for interior mutability stdl…

…ib types

It's basically the same as the serde implementations from 5 years ago
serde-rs/serde#882 .

borsh/src/de/mod.rs

@@ -908,6 +908,47 @@ impl<T: ?Sized> BorshDeserialize for PhantomData<T> {
         Ok(PhantomData)
     }
 }
+
+#[cfg(feature = "std")]
+impl<T> BorshDeserialize for core::cell::Cell<T>
+where
+    T: BorshDeserialize,
+{
+    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
+        <T as BorshDeserialize>::deserialize_reader(reader).map(core::cell::Cell::new)
+    }
+}
+
+#[cfg(feature = "std")]
+impl<T> BorshDeserialize for core::cell::RefCell<T>
+where
+    T: BorshDeserialize,
+{
+    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
+        <T as BorshDeserialize>::deserialize_reader(reader).map(core::cell::RefCell::new)
+    }
+}
+
+#[cfg(feature = "std")]
+impl<T> BorshDeserialize for std::sync::Mutex<T>
+where
+    T: BorshDeserialize,
+{
+    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
+        <T as BorshDeserialize>::deserialize_reader(reader).map(std::sync::Mutex::new)
+    }
+}
+
+#[cfg(feature = "std")]
+impl<T> BorshDeserialize for std::sync::RwLock<T>
+where
+    T: BorshDeserialize,
+{
+    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
+        <T as BorshDeserialize>::deserialize_reader(reader).map(std::sync::RwLock::new)
+    }
+}
+
 /// Deserializes an object from a slice of bytes.
 /// # Example
 /// ```

borsh/src/ser/mod.rs

@@ -619,3 +619,55 @@ impl<T: ?Sized> BorshSerialize for PhantomData<T> {
         Ok(())
     }
 }
+
+#[cfg(feature = "std")]
+impl<T> BorshSerialize for core::cell::Cell<T>
+where
+    T: BorshSerialize + Copy,
+{
+    fn serialize<W: Write>(&self, writer: &mut W) -> Result<()> {
+        <T as BorshSerialize>::serialize(&self.get(), writer)
+    }
+}
+
+#[cfg(feature = "std")]
+impl<T> BorshSerialize for core::cell::RefCell<T>
+where
+    T: BorshSerialize,
+{
+    fn serialize<W: Write>(&self, writer: &mut W) -> Result<()> {
+        <T as BorshSerialize>::serialize(core::ops::Deref::deref(&self.borrow()), writer)
+    }
+}
+
+#[cfg(feature = "std")]
+impl<T> BorshSerialize for std::sync::Mutex<T>
+where
+    T: BorshSerialize,
+{
+    fn serialize<W: Write>(&self, writer: &mut W) -> Result<()> {
+        match self.lock().as_deref() {
+            Ok(locked) => <T as BorshSerialize>::serialize(locked, writer),
+            Err(_) => Err(Error::new(
+                ErrorKind::InvalidData,
+                "lock poison error while serializing",
+            )),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl<T> BorshSerialize for std::sync::RwLock<T>
+where
+    T: BorshSerialize,
+{
+    fn serialize<W: Write>(&self, writer: &mut W) -> Result<()> {
+        match self.read().as_deref() {
+            Ok(locked) => <T as BorshSerialize>::serialize(locked, writer),
+            Err(_) => Err(Error::new(
+                ErrorKind::InvalidData,
+                "lock poison error while serializing",
+            )),
+        }
+    }
+}