serde support for valence_nbt + fixes. (#352)

## Description

- Reorganize `valence_nbt` and feature flag the different parts. SNBT
and binary serialization are each behind their own flags.
- Add optional serde support to `valence_nbt` behind the `serde` flag.
This is useful for end users working with `valence_nbt` and allows us to
simplify some code in `valence_biome` and `valence_dimension`.

Note that this includes a `Serializer` and `Deserializer` for `Compound`
and _not_ the binary and SNBT formats. In other words, it's not possible
to go directly from an arbitrary data format to binary NBT and vice
versa, but it _is_ possible to go to and from `Compound` and finish the
(de)serialization this way. I consider this an acceptable compromise
because writing fast and correct serialization routines for `Compound`
becomes more difficult when serde is in the way. Besides, the
intermediate `Compound` often needs to be created anyway.
- Fixed unsound uses of `std::mem::transmute` in `valence_nbt` and
elsewhere. Using `transmute` to cast between slice types is unsound
because slices are `#[repr(Rust)]` and the layouts are not guaranteed.
`slice::from_raw_parts` is used as the replacement.

Author: rj00a

Cargo.toml

@@ -47,6 +47,7 @@ num-integer = "0.1.45"
 owo-colors = "3.5.0"
 parking_lot = "0.12.1"
 paste = "1.0.11"
+pretty_assertions = "1.3.0"
 proc-macro2 = "1.0.56"
 quote = "1.0.26"
 rand = "0.8.5"
@@ -84,7 +85,7 @@ valence_dimension.path = "crates/valence_dimension"
 valence_entity.path = "crates/valence_entity"
 valence_instance.path = "crates/valence_instance"
 valence_inventory.path = "crates/valence_inventory"
-valence_nbt = { path = "crates/valence_nbt", features = ["uuid"] }
+valence_nbt = { path = "crates/valence_nbt" }
 valence_network.path = "crates/valence_network"
 valence_player_list.path = "crates/valence_player_list"
 valence_registry.path = "crates/valence_registry"

crates/valence_anvil/src/lib.rs

@@ -56,7 +56,7 @@ pub enum ReadChunkError {
     #[error(transparent)]
     Io(#[from] io::Error),
     #[error(transparent)]
-    Nbt(#[from] valence_nbt::Error),
+    Nbt(#[from] valence_nbt::binary::Error),
     #[error("invalid chunk sector offset")]
     BadSectorOffset,
     #[error("invalid chunk size")]
@@ -180,7 +180,7 @@ impl AnvilWorld {
             b => return Err(ReadChunkError::UnknownCompressionScheme(b)),
         };
 
-        let (data, _) = valence_nbt::from_binary_slice(&mut nbt_slice)?;
+        let (data, _) = Compound::from_binary(&mut nbt_slice)?;
 
         if !nbt_slice.is_empty() {
             return Err(ReadChunkError::IncompleteNbtRead);

crates/valence_core/Cargo.toml

@@ -24,7 +24,7 @@ serde_json.workspace = true
 thiserror.workspace = true
 tracing.workspace = true
 uuid = { workspace = true, features = ["serde"] }
-valence_nbt.workspace = true
+valence_nbt = { workspace = true, features = ["binary"] }
 valence_core_macros.workspace = true
 url.workspace = true
 base64.workspace = true

crates/valence_core/src/protocol/impls.rs

@@ -1,5 +1,6 @@
 //! [`Encode`] and [`Decode`] impls on foreign types.
 
+use core::slice;
 use std::borrow::Cow;
 use std::collections::{BTreeSet, HashSet};
 use std::hash::{BuildHasher, Hash};
@@ -27,8 +28,8 @@ impl Encode for bool {
 
     fn encode_slice(slice: &[bool], mut w: impl Write) -> Result<()> {
         // SAFETY: Bools have the same layout as u8.
+        let bytes = unsafe { slice::from_raw_parts(slice.as_ptr() as *const u8, slice.len()) };
         // Bools are guaranteed to have the correct bit pattern.
-        let bytes: &[u8] = unsafe { mem::transmute(slice) };
         Ok(w.write_all(bytes)?)
     }
 }
@@ -64,7 +65,7 @@ impl Encode for i8 {
 
     fn encode_slice(slice: &[i8], mut w: impl Write) -> Result<()> {
         // SAFETY: i8 has the same layout as u8.
-        let bytes: &[u8] = unsafe { mem::transmute(slice) };
+        let bytes = unsafe { slice::from_raw_parts(slice.as_ptr() as *const u8, slice.len()) };
         Ok(w.write_all(bytes)?)
     }
 }
@@ -471,7 +472,6 @@ impl<const N: usize, T: Encode> Encode for [T; N] {
 impl<'a, const N: usize, T: Decode<'a>> Decode<'a> for [T; N] {
     fn decode(r: &mut &'a [u8]) -> Result<Self> {
         // TODO: rewrite using std::array::try_from_fn when stabilized?
-        // TODO: specialization for [f64; 3] improved performance.
 
         let mut data: [MaybeUninit<T>; N] = unsafe { MaybeUninit::uninit().assume_init() };
 
@@ -539,9 +539,12 @@ impl<'a> Decode<'a> for &'a [u8] {
 
 impl<'a> Decode<'a> for &'a [i8] {
     fn decode(r: &mut &'a [u8]) -> Result<Self> {
-        let unsigned_bytes = <&[u8]>::decode(r)?;
-        let signed_bytes: &[i8] = unsafe { mem::transmute(unsigned_bytes) };
-        Ok(signed_bytes)
+        let bytes = <&[u8]>::decode(r)?;
+
+        // SAFETY: i8 and u8 have the same layout.
+        let bytes = unsafe { slice::from_raw_parts(bytes.as_ptr() as *const i8, bytes.len()) };
+
+        Ok(bytes)
     }
 }
 
@@ -765,12 +768,12 @@ impl<'a> Decode<'a> for Uuid {
 
 impl Encode for Compound {
     fn encode(&self, w: impl Write) -> Result<()> {
-        Ok(valence_nbt::to_binary_writer(w, self, "")?)
+        Ok(self.to_binary(w, "")?)
     }
 }
 
 impl Decode<'_> for Compound {
     fn decode(r: &mut &[u8]) -> Result<Self> {
-        Ok(valence_nbt::from_binary_slice(r)?.0)
+        Ok(Self::from_binary(r)?.0)
     }
 }

crates/valence_nbt/Cargo.toml

@@ -10,11 +10,20 @@ version = "0.5.0"
 edition.workspace = true
 
 [features]
+binary = ["dep:byteorder", "dep:cesu8"]
+snbt = []
 # When enabled, the order of fields in compounds are preserved.
 preserve_order = ["dep:indexmap"]
+serde = ["dep:serde", "dep:thiserror", "indexmap?/serde"]
 
 [dependencies]
-byteorder.workspace = true
-cesu8.workspace = true
+byteorder = { workspace = true, optional = true }
+cesu8 = { workspace = true, optional = true }
 indexmap = { workspace = true, optional = true }
+serde = { workspace = true, features = ["derive"], optional = true }
+thiserror = { workspace = true, optional = true }
 uuid = { workspace = true, optional = true }
+
+[dev-dependencies]
+pretty_assertions.workspace = true
+serde_json.workspace = true

crates/valence_nbt/README.md

@@ -5,48 +5,10 @@ format.
 
 [Named Binary Tag]: https://minecraft.fandom.com/wiki/NBT_format
 
-# Examples
-
-Encode NBT data to its binary form. We are using the [`compound!`] macro to
-conveniently construct [`Compound`] values.
-
-```rust
-use valence_nbt::{compound, to_binary_writer, List};
-
-let c = compound! {
-    "byte" => 5_i8,
-    "string" => "hello",
-    "list_of_float" => List::Float(vec![
-        3.1415,
-        2.7182,
-        1.4142
-    ]),
-};
-
-let mut buf = vec![];
-
-to_binary_writer(&mut buf, &c, "").unwrap();
-```
-
-Decode NBT data from its binary form.
-
-```rust
-use valence_nbt::{compound, from_binary_slice};
-
-let some_bytes = [10, 0, 0, 3, 0, 3, 105, 110, 116, 0, 0, 222, 173, 0];
-
-let expected_value = compound! {
-    "int" => 0xdead
-};
-
-let (nbt, root_name) = from_binary_slice(&mut some_bytes.as_slice()).unwrap();
-
-assert_eq!(nbt, expected_value);
-assert_eq!(root_name, "");
-```
-
 # Features
-
+- `binary`: Adds support for serializing and deserializing in Java edition's binary format.
+- `snbt`: Adds support for serializing and deserializing in "stringified" format.
 - `preserve_order`: Causes the order of fields in [`Compound`]s to be
 preserved during insertion and deletion at a slight cost to performance.
 The iterators on `Compound` can then implement [`DoubleEndedIterator`].
+- `serde` Adds support for [`serde`](https://docs.rs/serde/latest/serde/)

crates/valence_nbt/src/binary.rs

@@ -0,0 +1,48 @@
+//! Support for serializing and deserializing compounds in Java edition's binary
+//! format.
+//!
+//! # Examples
+//!
+//! ```
+//! use valence_nbt::{compound, Compound, List};
+//!
+//! let c = compound! {
+//!     "byte" => 5_i8,
+//!     "string" => "hello",
+//!     "list_of_float" => List::Float(vec![
+//!         3.1415,
+//!         2.7182,
+//!         1.4142
+//!     ]),
+//! };
+//!
+//! let mut buf = vec![];
+//!
+//! c.to_binary(&mut buf, "").unwrap();
+//! ```
+//!
+//! Decode NBT data from its binary form.
+//!
+//! ```
+//! use valence_nbt::{compound, Compound};
+//!
+//! let some_bytes = [10, 0, 0, 3, 0, 3, 105, 110, 116, 0, 0, 222, 173, 0];
+//!
+//! let expected_value = compound! {
+//!     "int" => 0xdead
+//! };
+//!
+//! let (nbt, root_name) = Compound::from_binary(&mut some_bytes.as_slice()).unwrap();
+//!
+//! assert_eq!(nbt, expected_value);
+//! assert_eq!(root_name, "");
+//! ```
+
+mod decode;
+mod encode;
+mod error;
+mod modified_utf8;
+#[cfg(test)]
+mod tests;
+
+pub use error::*;