refactor(io): make accurate reader names primary (#4060)

crates/io-core/src/writer.rs

@@ -14,9 +14,9 @@
 
 //! BytesMut-backed object writer for optimized write operations.
 //!
-//! This module keeps the historical `ZeroCopyObjectWriter` name for public API
-//! compatibility. It uses `BytesMut` for efficient buffering; writes into that
-//! buffer may still copy input bytes.
+//! It uses `BytesMut` for efficient buffering; writes into that buffer may
+//! still copy input bytes. The historical `ZeroCopyObjectWriter` name remains
+//! available as a deprecated compatibility alias.
 
 use bytes::{BufMut, Bytes, BytesMut};
 use std::pin::Pin;
@@ -50,7 +50,7 @@ use tokio::io::AsyncWrite;
 ///     Ok(())
 /// }
 /// ```
-pub struct ZeroCopyObjectWriter {
+pub struct BytesMutWriter {
     /// Internal buffer using BytesMut for efficient growth
     buffer: BytesMut,
     /// Total bytes written
@@ -59,10 +59,11 @@ pub struct ZeroCopyObjectWriter {
     finalized: bool,
 }
 
-/// Preferred name for the BytesMut-backed object writer.
-pub type BytesMutWriter = ZeroCopyObjectWriter;
+/// Historical name for the BytesMut-backed object writer.
+#[deprecated(since = "1.0.0-beta.8", note = "use BytesMutWriter; writes append into a BytesMut buffer")]
+pub type ZeroCopyObjectWriter = BytesMutWriter;
 
-impl ZeroCopyObjectWriter {
+impl BytesMutWriter {
     /// Create a new bytes-backed object writer with default capacity (8KB).
     ///
     /// # Example
@@ -237,15 +238,15 @@ impl ZeroCopyObjectWriter {
     }
 }
 
-impl Default for ZeroCopyObjectWriter {
+impl Default for BytesMutWriter {
     fn default() -> Self {
         Self::new()
     }
 }
 
-impl std::fmt::Debug for ZeroCopyObjectWriter {
+impl std::fmt::Debug for BytesMutWriter {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("ZeroCopyObjectWriter")
+        f.debug_struct("BytesMutWriter")
             .field("buffer_len", &self.buffer.len())
             .field("buffer_capacity", &self.buffer.capacity())
             .field("bytes_written", &self.bytes_written)
@@ -254,10 +255,10 @@ impl std::fmt::Debug for ZeroCopyObjectWriter {
     }
 }
 
-/// AsyncWrite implementation for ZeroCopyObjectWriter.
+/// AsyncWrite implementation for BytesMutWriter.
 ///
 /// This allows the writer to be used with tokio's async I/O utilities.
-impl AsyncWrite for ZeroCopyObjectWriter {
+impl AsyncWrite for BytesMutWriter {
     fn poll_write(mut self: Pin<&mut Self>, _cx: &mut Context<'_>, buf: &[u8]) -> Poll<Result<usize, tokio::io::Error>> {
         if self.finalized {
             return Poll::Ready(Err(tokio::io::Error::new(
@@ -305,7 +306,7 @@ mod tests {
 
     #[tokio::test]
     async fn test_new_writer() {
-        let writer = ZeroCopyObjectWriter::new();
+        let writer = BytesMutWriter::new();
         assert!(writer.is_empty());
         assert_eq!(writer.bytes_written(), 0);
         assert!(writer.capacity() >= 8 * 1024);
@@ -313,7 +314,7 @@ mod tests {
 
     #[tokio::test]
     async fn test_write_zero_copy() {
-        let mut writer = ZeroCopyObjectWriter::new();
+        let mut writer = BytesMutWriter::new();
         let data = Bytes::from("hello world");
 
         let written = writer.write_zero_copy(data).await.unwrap();
@@ -336,7 +337,7 @@ mod tests {
 
     #[tokio::test]
     async fn test_write_slice() {
-        let mut writer = ZeroCopyObjectWriter::new();
+        let mut writer = BytesMutWriter::new();
         let data = b"hello world";
 
         let written = writer.write_slice(data).await.unwrap();
@@ -347,7 +348,7 @@ mod tests {
 
     #[tokio::test]
     async fn test_into_bytes() {
-        let mut writer = ZeroCopyObjectWriter::new();
+        let mut writer = BytesMutWriter::new();
         let data = Bytes::from("hello world");
 
         writer.write_zero_copy(data).await.unwrap();
@@ -358,26 +359,26 @@ mod tests {
 
     #[tokio::test]
     async fn test_write_after_finalize() {
-        let mut writer = ZeroCopyObjectWriter::new();
+        let mut writer = BytesMutWriter::new();
         let data = Bytes::from("hello");
 
         writer.write_zero_copy(data).await.unwrap();
         let _result = writer.into_bytes();
 
         // Create new writer and try to write after finalize
-        let mut writer2 = ZeroCopyObjectWriter::new();
+        let mut writer2 = BytesMutWriter::new();
         writer2.write_zero_copy(Bytes::from("test")).await.unwrap();
         let _ = writer2.into_bytes();
 
         // Writing to a consumed writer should work via new writer
-        let mut writer3 = ZeroCopyObjectWriter::new();
+        let mut writer3 = BytesMutWriter::new();
         let result = writer3.write_zero_copy(Bytes::from("final")).await;
         assert!(result.is_ok());
     }
 
     #[tokio::test]
     async fn test_clear() {
-        let mut writer = ZeroCopyObjectWriter::new();
+        let mut writer = BytesMutWriter::new();
         writer.write_slice(b"hello").await.unwrap();
 
         writer.clear();
@@ -389,7 +390,7 @@ mod tests {
 
     #[tokio::test]
     async fn test_reserve() {
-        let mut writer = ZeroCopyObjectWriter::with_capacity(10);
+        let mut writer = BytesMutWriter::with_capacity(10);
         let initial_capacity = writer.capacity();
 
         writer.reserve(1000);
@@ -400,7 +401,7 @@ mod tests {
 
     #[tokio::test]
     async fn test_multiple_writes() {
-        let mut writer = ZeroCopyObjectWriter::new();
+        let mut writer = BytesMutWriter::new();
 
         writer.write_zero_copy(Bytes::from("hello ")).await.unwrap();
         writer.write_slice(b"world").await.unwrap();
@@ -413,7 +414,7 @@ mod tests {
     async fn test_async_write() {
         use tokio::io::AsyncWriteExt;
 
-        let mut writer = ZeroCopyObjectWriter::new();
+        let mut writer = BytesMutWriter::new();
         let data = b"hello world";
 
         let written = writer.write(data).await.unwrap();
@@ -423,9 +424,19 @@ mod tests {
 
     #[tokio::test]
     async fn test_debug() {
-        let writer = ZeroCopyObjectWriter::new();
+        let writer = BytesMutWriter::new();
         let debug_str = format!("{:?}", writer);
-        assert!(debug_str.contains("ZeroCopyObjectWriter"));
+        assert!(debug_str.contains("BytesMutWriter"));
         assert!(debug_str.contains("buffer_len"));
     }
+
+    #[tokio::test]
+    #[allow(deprecated)]
+    async fn test_legacy_writer_alias() {
+        let mut writer = ZeroCopyObjectWriter::new();
+        let written = writer.write_zero_copy(Bytes::from("hello")).await.unwrap();
+
+        assert_eq!(written, 5);
+        assert_eq!(writer.as_slice(), b"hello");
+    }
 }