Remove Simd-json (#228)

This mirrors the serenity pr https://github.com/serenity-rs/serenity/pull/2735.

src/error.rs

@@ -6,8 +6,6 @@ use futures::channel::mpsc::TrySendError;
 pub use serde_json::Error as JsonError;
 #[cfg(feature = "serenity")]
 use serenity::gateway::ShardRunnerMessage;
-#[cfg(feature = "simd-json")]
-pub use simd_json::Error as JsonError;
 #[cfg(feature = "gateway")]
 use std::{error::Error, fmt};
 #[cfg(feature = "twilight")]

src/input/adapters/cached/compressed.rs

@@ -196,7 +196,7 @@ impl Compressed {
         )?;
         let mut metabytes = b"DCA1\0\0\0\0".to_vec();
         let orig_len = metabytes.len();
-        crate::json::to_writer(&mut metabytes, &metadata)?;
+        serde_json::to_writer(&mut metabytes, &metadata)?;
         let meta_len = (metabytes.len() - orig_len)
             .try_into()
             .map_err(|_| CodecCacheError::MetadataTooLarge)?;

src/input/codecs/dca/mod.rs

@@ -109,11 +109,9 @@ impl FormatReader for DcaReader {
                 return symph_err::decode_error("missing DCA1 metadata block");
             }
 
-            let mut raw_json = source.read_boxed_slice_exact(size as usize)?;
+            let raw_json = source.read_boxed_slice_exact(size as usize)?;
 
-            // NOTE: must be mut for simd-json.
-            #[allow(clippy::unnecessary_mut_passed)]
-            let metadata: DcaMetadata = crate::json::from_slice::<DcaMetadata>(&mut raw_json)
+            let metadata: DcaMetadata = serde_json::from_slice::<DcaMetadata>(&raw_json)
                 .map_err(|_| SymphError::DecodeError("malformed DCA1 metadata block"))?;
 
             let mut revision = MetadataBuilder::new();

src/input/metadata/mod.rs

@@ -49,7 +49,7 @@ pub struct AuxMetadata {
 impl AuxMetadata {
     /// Extract metadata and details from the output of `ffprobe -of json`.
     pub fn from_ffprobe_json(value: &mut [u8]) -> Result<Self, JsonError> {
-        let output: ffprobe::Output = crate::json::from_slice(value)?;
+        let output: ffprobe::Output = serde_json::from_slice(value)?;
 
         Ok(output.into_aux_metadata())
     }

src/input/sources/ytdl.rs

@@ -164,11 +164,11 @@ impl<'a> YoutubeDl<'a> {
             ));
         }
 
-        // NOTE: must be split_mut for simd-json.
         let out = output
             .stdout
-            .split_mut(|&b| b == b'\n')
-            .filter_map(|x| (!x.is_empty()).then(|| crate::json::from_slice(x)))
+            .split(|&b| b == b'\n')
+            .filter(|&x| (!x.is_empty()))
+            .map(|x| serde_json::from_slice(x))
             .collect::<Result<Vec<Output>, _>>()
             .map_err(|e| AudioStreamError::Fail(Box::new(e)))?;
 

src/lib.rs

@@ -113,11 +113,7 @@ pub use discortp as packet;
 #[cfg(feature = "driver")]
 pub use serenity_voice_model as model;
 
-// Re-export serde-json APIs locally to minimise conditional config elsewhere.
-#[cfg(not(feature = "simd-json"))]
 pub(crate) use serde_json as json;
-#[cfg(feature = "simd-json")]
-pub(crate) use simd_json::serde as json;
 
 #[cfg(feature = "driver")]
 pub use crate::{

src/ws.rs

@@ -128,22 +128,10 @@ impl From<TwsError> for Error {
 }
 
 #[inline]
-#[allow(unused_unsafe)]
 pub(crate) fn convert_ws_message(message: Option<Message>) -> Result<Option<Event>> {
     #[cfg(feature = "tungstenite")]
-    return Ok(match message {
-        // SAFETY:
-        // simd-json::serde::from_str may leave an &mut str in a non-UTF state on failure.
-        // The below is safe as we have taken ownership of the inner `String`, and if
-        // failure occurs we forcibly re-validate its contents before logging.
-        Some(Message::Text(mut payload)) =>
-            (unsafe { crate::json::from_str(payload.as_mut_str()) })
-                .map_err(|e| {
-                    let safe_payload = String::from_utf8_lossy(payload.as_bytes());
-                    debug!("Unexpected JSON: {e}. Payload: {safe_payload}");
-                    e
-                })
-                .ok(),
+    let text = match message {
+        Some(Message::Text(ref payload)) => payload,
         Some(Message::Binary(bytes)) => {
             return Err(Error::UnexpectedBinaryMessage(bytes));
         },
@@ -151,34 +139,32 @@ pub(crate) fn convert_ws_message(message: Option<Message>) -> Result<Option<Even
             return Err(Error::WsClosed(Some(frame)));
         },
         // Ping/Pong message behaviour is internally handled by tungstenite.
-        _ => None,
-    });
+        _ => return Ok(None),
+    };
     #[cfg(feature = "tws")]
-    return Ok(if let Some(message) = message {
-        if message.is_text() {
-            let mut payload = message.as_text().unwrap().to_owned();
-            // SAFETY:
-            // simd-json::serde::from_str may leave an &mut str in a non-UTF state on failure.
-            // The below is safe as we have created an owned copy of the payload `&str`, and if
-            // failure occurs we forcibly re-validate its contents before logging.
-            (unsafe { crate::json::from_str(payload.as_mut_str()) })
-                .map_err(|e| {
-                    let safe_payload = String::from_utf8_lossy(payload.as_bytes());
-                    debug!("Unexpected JSON: {e}. Payload: {safe_payload}");
-                    e
-                })
-                .ok()
-        } else if message.is_binary() {
+    let text = match message {
+        Some(ref message) if message.is_text() =>
+            if let Some(text) = message.as_text() {
+                text
+            } else {
+                return Ok(None);
+            },
+        Some(message) if message.is_binary() => {
             return Err(Error::UnexpectedBinaryMessage(
                 message.into_payload().to_vec(),
             ));
-        } else if message.is_close() {
+        },
+        Some(message) if message.is_close() => {
             return Err(Error::WsClosed(message.as_close().map(|(c, _)| c)));
-        } else {
-            // ping/pong; will also be internally handled by tokio-websockets
-            None
-        }
-    } else {
-        None
-    });
+        },
+        // ping/pong; will also be internally handled by tokio-websockets.
+        _ => return Ok(None),
+    };
+
+    Ok(serde_json::from_str(text)
+        .map_err(|e| {
+            debug!("Unexpected JSON: {e}. Payload: {text}");
+            e
+        })
+        .ok())
 }