WIP: Turbopack: Remove remaining dead implementations of serde traits

Author: bgw

Cargo.lock

@@ -446,7 +446,6 @@ rstest = "0.16.0"
 rustc-hash = "2.1.1"
 semver = "1.0.16"
 serde = { version = "1.0.217", features = ["derive"] }
-serde_bytes = "0.11.15"
 serde_json = "1.0.138"
 serde_path_to_error = "0.1.16"
 serde_qs = "0.13.0"

Cargo.toml

@@ -9,10 +9,7 @@ anyhow = { workspace = true }
 bincode = { workspace = true }
 regex = { workspace = true }
 regress = { workspace = true }
-serde = { workspace = true }
-serde_json = { workspace = true }
 turbo-tasks = { workspace = true }
 
-
 [lints]
 workspace = true

turbopack/crates/turbo-esregex/Cargo.toml

@@ -10,14 +10,12 @@ use bincode::{
     error::{DecodeError, EncodeError},
     impl_borrow_decode,
 };
-use serde::{Deserialize, Serialize};
 
 /// A simple regular expression implementation following ecmascript semantics
 ///
 /// Delegates to the `regex` crate when possible and `regress` otherwise.
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone)]
 #[turbo_tasks::value(eq = "manual", shared, serialization = "custom")]
-#[serde(into = "RegexForm", try_from = "RegexForm")]
 pub struct EsRegex {
     #[turbo_tasks(trace_ignore)]
     delegate: EsRegexImpl,
@@ -44,30 +42,6 @@ impl PartialEq for EsRegex {
 }
 impl Eq for EsRegex {}
 
-impl TryFrom<RegexForm> for EsRegex {
-    type Error = anyhow::Error;
-
-    fn try_from(value: RegexForm) -> std::result::Result<Self, Self::Error> {
-        EsRegex::new(&value.pattern, &value.flags)
-    }
-}
-
-/// This is the serializable form for the `EsRegex` struct
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone)]
-struct RegexForm {
-    pattern: String,
-    flags: String,
-}
-
-impl From<EsRegex> for RegexForm {
-    fn from(value: EsRegex) -> Self {
-        Self {
-            pattern: value.pattern,
-            flags: value.flags,
-        }
-    }
-}
-
 impl Encode for EsRegex {
     fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
         self.pattern.encode(encoder)?;
@@ -235,11 +209,13 @@ mod tests {
     use super::{EsRegex, EsRegexImpl};
 
     #[test]
-    fn round_trip_serialize() {
+    fn round_trip_bincode() {
         let regex = EsRegex::new("[a-z]", "i").unwrap();
-        let serialized = serde_json::to_string(&regex).unwrap();
-        let parsed = serde_json::from_str::<EsRegex>(&serialized).unwrap();
-        assert_eq!(regex, parsed);
+        let config = bincode::config::standard();
+        let encoded = bincode::encode_to_vec(&regex, config).unwrap();
+        let (decoded, len) = bincode::decode_from_slice::<EsRegex, _>(&encoded, config).unwrap();
+        assert_eq!(regex, decoded);
+        assert_eq!(len, encoded.len());
     }
 
     #[test]

turbopack/crates/turbo-esregex/src/lib.rs

@@ -17,8 +17,4 @@ bincode = { workspace = true }
 bytes = { workspace = true }
 futures = { workspace = true }
 serde = { workspace = true }
-serde_bytes = "0.11.9"
 turbo-tasks = { workspace = true }
-
-[dev-dependencies]
-serde_test = "1.0.157"

turbopack/crates/turbo-tasks-bytes/Cargo.toml

@@ -12,7 +12,6 @@ use bincode::{
     impl_borrow_decode,
 };
 use bytes::Bytes as CBytes;
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 /// Bytes is a thin wrapper around [bytes::Bytes], implementing easy
 /// conversion to/from, ser/de support, and Vc containers.
@@ -26,19 +25,6 @@ impl Bytes {
     }
 }
 
-impl Serialize for Bytes {
-    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        serde_bytes::Bytes::new(&self.0).serialize(serializer)
-    }
-}
-
-impl<'de> Deserialize<'de> for Bytes {
-    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
-        let bytes = serde_bytes::ByteBuf::deserialize(deserializer)?;
-        Ok(Bytes(bytes.into_vec().into()))
-    }
-}
-
 impl Encode for Bytes {
     fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
         self[..].encode(encoder)
@@ -92,10 +78,8 @@ impl From<Bytes> for CBytes {
 
 #[cfg(test)]
 mod tests {
-    use bytes::Bytes as CBytes;
-    use serde_test::{Token, assert_tokens};
+    use super::*;
 
-    use super::Bytes;
     impl PartialEq<&str> for Bytes {
         fn eq(&self, other: &&str) -> bool {
             self.0 == other
@@ -112,12 +96,6 @@ mod tests {
         assert_eq!(Bytes::from(s), "foo");
     }
 
-    #[test]
-    fn serde() {
-        let s = Bytes::from("test");
-        assert_tokens(&s, &[Token::Bytes(b"test")])
-    }
-
     #[test]
     fn bincode() {
         let s = Bytes::from("test");

turbopack/crates/turbo-tasks-bytes/src/bytes.rs

@@ -13,7 +13,6 @@ use bincode::{
     error::{DecodeError, EncodeError},
 };
 use futures::{Stream as StreamTrait, StreamExt, TryStreamExt};
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 /// Streams allow for streaming values from source to sink.
 ///
@@ -153,27 +152,6 @@ impl<T: Clone + PartialEq + Send> PartialEq for Stream<T> {
 }
 impl<T: Clone + Eq + Send> Eq for Stream<T> {}
 
-impl<T: Clone + Serialize + Send> Serialize for Stream<T> {
-    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        use serde::ser::Error;
-        let lock = self.inner.lock().map_err(Error::custom)?;
-        match &*lock {
-            StreamState {
-                pulled,
-                source: None,
-            } => pulled.serialize(serializer),
-            _ => Err(Error::custom("cannot serialize open stream")),
-        }
-    }
-}
-
-impl<'de, T: Clone + Send + Deserialize<'de>> Deserialize<'de> for Stream<T> {
-    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
-        let data = <Vec<T>>::deserialize(deserializer)?;
-        Ok(Stream::new_closed(data))
-    }
-}
-
 impl<T: Clone + Encode + Send> Encode for Stream<T> {
     fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
         let lock = self

turbopack/crates/turbo-tasks-bytes/src/stream.rs

@@ -41,7 +41,6 @@ parking_lot = { workspace = true }
 regex = { workspace = true }
 rustc-hash = { workspace = true }
 serde = { workspace = true, features = ["rc"] }
-serde_bytes = { workspace = true }
 serde_json = { workspace = true }
 serde_path_to_error = { workspace = true }
 tokio = { workspace = true }

turbopack/crates/turbo-tasks-fs/Cargo.toml

@@ -20,8 +20,6 @@ use bincode::{
 };
 use bytes::Bytes;
 use futures::Stream;
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
-use serde_bytes::ByteBuf;
 use tokio::io::{AsyncRead, ReadBuf};
 use triomphe::Arc;
 use turbo_tasks_hash::{DeterministicHash, DeterministicHasher};
@@ -393,27 +391,6 @@ impl DeterministicHash for Rope {
     }
 }
 
-impl Serialize for Rope {
-    /// Ropes are always serialized into contiguous strings, because
-    /// deserialization won't deduplicate and share the Arcs (being the only
-    /// possible owner of a individual "shared" data doesn't make sense).
-    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        let bytes = self.to_bytes();
-        match bytes {
-            Cow::Borrowed(b) => serde_bytes::Bytes::new(b).serialize(serializer),
-            Cow::Owned(b) => ByteBuf::from(b).serialize(serializer),
-        }
-    }
-}
-
-impl<'de> Deserialize<'de> for Rope {
-    /// Deserializes strings into a contiguous, immutable Rope.
-    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
-        let bytes = ByteBuf::deserialize(deserializer)?.into_vec();
-        Ok(Rope::from(bytes))
-    }
-}
-
 /// Encode as a len + raw bytes format using the encoder's [`bincode::enc::write::Writer`]. Encoding
 /// [`Rope::to_bytes`] instead would be easier, but would require copying to an intermediate buffer.
 ///

turbopack/crates/turbo-tasks-fs/src/rope.rs

@@ -8,15 +8,14 @@ use std::{
 use auto_hash_map::AutoSet;
 use bincode::{Decode, Encode};
 use parking_lot::{Mutex, MutexGuard};
-use serde::{Deserialize, Serialize};
 use tracing::trace_span;
 
 use crate::{
     Invalidator, OperationValue, SerializationInvalidator, get_invalidator, mark_session_dependent,
     mark_stateful, trace::TraceRawVcs,
 };
 
-#[derive(Serialize, Deserialize, Encode, Decode)]
+#[derive(Encode, Decode)]
 struct StateInner<T> {
     value: T,
     invalidators: AutoSet<Invalidator>,
@@ -161,7 +160,7 @@ mod parking_lot_mutex_bincode {
 /// [strong consistency]: crate::OperationVc::read_strongly_consistent
 /// [`OperationVc`]: crate::OperationVc
 /// [`OperationValue`]: crate::OperationValue
-#[derive(Serialize, Deserialize, Encode, Decode)]
+#[derive(Encode, Decode)]
 pub struct State<T> {
     serialization_invalidator: SerializationInvalidator,
     #[bincode(with = "parking_lot_mutex_bincode")]
@@ -272,10 +271,9 @@ impl<T: PartialEq> State<T> {
     }
 }
 
-#[derive(Serialize, Deserialize, Encode, Decode)]
+#[derive(Encode, Decode)]
 #[bincode(bounds = "")]
 pub struct TransientState<T> {
-    #[serde(skip, default = "default_transient_state_inner")]
     #[bincode(skip, default = "default_transient_state_inner")]
     inner: Mutex<StateInner<Option<T>>>,
 }