cleanup(serde_v8): disambiguate ZeroCopyBuf (#14380)

1 files changed, 26 insertions, 26 deletions

diff --git a/serde_v8/magic/buffer.rs b/serde_v8/magic/buffer.rs
index dfa6928fb..81f550bcb 100644
--- a/serde_v8/magic/buffer.rs
+++ b/serde_v8/magic/buffer.rs
@@ -7,101 +7,101 @@ use std::sync::Mutex;
 
 use super::transl8::FromV8;
 use super::transl8::ToV8;
-use super::zero_copy_buf::ZeroCopyBuf;
+use super::v8slice::V8Slice;
 use crate::magic::transl8::impl_magic;
 
-// An asymmetric wrapper around ZeroCopyBuf,
+// An asymmetric wrapper around V8Slice,
 // allowing us to use a single type for familiarity
-pub enum MagicBuffer {
-  FromV8(ZeroCopyBuf),
+pub enum ZeroCopyBuf {
+  FromV8(V8Slice),
   ToV8(Mutex<Option<Box<[u8]>>>),
-  // Variant of the MagicBuffer than is never exposed to the JS.
+  // Variant of the ZeroCopyBuf than is never exposed to the JS.
   // Generally used to pass Vec<u8> backed buffers to resource methods.
   Temp(Vec<u8>),
 }
 
-impl_magic!(MagicBuffer);
+impl_magic!(ZeroCopyBuf);
 
-impl Debug for MagicBuffer {
+impl Debug for ZeroCopyBuf {
   fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
     f.debug_list().entries(self.as_ref().iter()).finish()
   }
 }
 
-impl MagicBuffer {
+impl ZeroCopyBuf {
   pub fn empty() -> Self {
-    MagicBuffer::ToV8(Mutex::new(Some(vec![0_u8; 0].into_boxed_slice())))
+    ZeroCopyBuf::ToV8(Mutex::new(Some(vec![0_u8; 0].into_boxed_slice())))
   }
 
   pub fn new_temp(vec: Vec<u8>) -> Self {
-    MagicBuffer::Temp(vec)
+    ZeroCopyBuf::Temp(vec)
   }
 
   // TODO(@littledivy): Temporary, this needs a refactor.
   pub fn to_temp(self) -> Vec<u8> {
     match self {
-      MagicBuffer::Temp(vec) => vec,
+      ZeroCopyBuf::Temp(vec) => vec,
       _ => unreachable!(),
     }
   }
 }
 
-impl Clone for MagicBuffer {
+impl Clone for ZeroCopyBuf {
   fn clone(&self) -> Self {
     match self {
       Self::FromV8(zbuf) => Self::FromV8(zbuf.clone()),
       Self::Temp(vec) => Self::Temp(vec.clone()),
-      Self::ToV8(_) => panic!("Don't Clone a MagicBuffer sent to v8"),
+      Self::ToV8(_) => panic!("Don't Clone a ZeroCopyBuf sent to v8"),
     }
   }
 }
 
-impl AsRef<[u8]> for MagicBuffer {
+impl AsRef<[u8]> for ZeroCopyBuf {
   fn as_ref(&self) -> &[u8] {
     &*self
   }
 }
 
-impl AsMut<[u8]> for MagicBuffer {
+impl AsMut<[u8]> for ZeroCopyBuf {
   fn as_mut(&mut self) -> &mut [u8] {
     &mut *self
   }
 }
 
-impl Deref for MagicBuffer {
+impl Deref for ZeroCopyBuf {
   type Target = [u8];
   fn deref(&self) -> &[u8] {
     match self {
       Self::FromV8(buf) => &*buf,
       Self::Temp(vec) => &*vec,
-      Self::ToV8(_) => panic!("Don't Deref a MagicBuffer sent to v8"),
+      Self::ToV8(_) => panic!("Don't Deref a ZeroCopyBuf sent to v8"),
     }
   }
 }
 
-impl DerefMut for MagicBuffer {
+impl DerefMut for ZeroCopyBuf {
   fn deref_mut(&mut self) -> &mut [u8] {
     match self {
       Self::FromV8(buf) => &mut *buf,
       Self::Temp(vec) => &mut *vec,
-      Self::ToV8(_) => panic!("Don't Deref a MagicBuffer sent to v8"),
+      Self::ToV8(_) => panic!("Don't Deref a ZeroCopyBuf sent to v8"),
     }
   }
 }
 
-impl From<Box<[u8]>> for MagicBuffer {
+impl From<Box<[u8]>> for ZeroCopyBuf {
   fn from(buf: Box<[u8]>) -> Self {
-    MagicBuffer::ToV8(Mutex::new(Some(buf)))
+    ZeroCopyBuf::ToV8(Mutex::new(Some(buf)))
   }
 }
 
-impl From<Vec<u8>> for MagicBuffer {
+impl From<Vec<u8>> for ZeroCopyBuf {
   fn from(vec: Vec<u8>) -> Self {
     vec.into_boxed_slice().into()
   }
 }
 
-impl ToV8 for MagicBuffer {
+impl ToV8 for ZeroCopyBuf {
   fn to_v8<'a>(
     &self,
     scope: &mut v8::HandleScope<'a>,
@@ -112,7 +112,7 @@ impl ToV8 for MagicBuffer {
         value.into()
       }
       Self::Temp(_) => unreachable!(),
-      Self::ToV8(x) => x.lock().unwrap().take().expect("MagicBuffer was empty"),
+      Self::ToV8(x) => x.lock().unwrap().take().expect("ZeroCopyBuf was empty"),
     };
 
     if buf.is_empty() {
@@ -136,11 +136,11 @@ impl ToV8 for MagicBuffer {
   }
 }
 
-impl FromV8 for MagicBuffer {
+impl FromV8 for ZeroCopyBuf {
   fn from_v8(
     scope: &mut v8::HandleScope,
     value: v8::Local<v8::Value>,
   ) -> Result<Self, crate::Error> {
-    Ok(Self::FromV8(ZeroCopyBuf::from_v8(scope, value)?))
+    Ok(Self::FromV8(V8Slice::from_v8(scope, value)?))
   }
 }