remove some unneeded impls

library/proc_macro/src/bridge/mod.rs

@@ -13,7 +13,7 @@ use std::ops::{Bound, Range};
 use std::sync::Once;
 use std::{fmt, marker, mem, panic, thread};
 
-use crate::{Delimiter, Level, Spacing};
+use crate::{Delimiter, Level};
 
 /// Higher-order macro describing the server RPC API, allowing automatic
 /// generation of type-safe Rust APIs, both client-side and server-side.
@@ -187,12 +187,6 @@ impl<'a, T, M> Unmark for &'a Marked<T, M> {
         &self.value
     }
 }
-impl<'a, T, M> Unmark for &'a mut Marked<T, M> {
-    type Unmarked = &'a mut T;
-    fn unmark(self) -> Self::Unmarked {
-        &mut self.value
-    }
-}
 
 impl<T: Mark> Mark for Vec<T> {
     type Unmarked = Vec<T::Unmarked>;
@@ -230,8 +224,6 @@ macro_rules! mark_noop {
 mark_noop! {
     (),
     bool,
-    char,
-    &'_ [u8],
     &'_ str,
     String,
     u8,
@@ -239,7 +231,6 @@ mark_noop! {
     Delimiter,
     LitKind,
     Level,
-    Spacing,
 }
 
 rpc_encode_decode!(
@@ -258,12 +249,6 @@ rpc_encode_decode!(
         Help,
     }
 );
-rpc_encode_decode!(
-    enum Spacing {
-        Alone,
-        Joint,
-    }
-);
 
 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
 pub enum LitKind {

library/proc_macro/src/bridge/rpc.rs

@@ -135,18 +135,6 @@ impl<S> Decode<'_, '_, S> for bool {
     }
 }
 
-impl<S> Encode<S> for char {
-    fn encode(self, w: &mut Buffer, s: &mut S) {
-        (self as u32).encode(w, s);
-    }
-}
-
-impl<S> Decode<'_, '_, S> for char {
-    fn decode(r: &mut &[u8], s: &mut S) -> Self {
-        char::from_u32(u32::decode(r, s)).unwrap()
-    }
-}
-
 impl<S> Encode<S> for NonZero<u32> {
     fn encode(self, w: &mut Buffer, s: &mut S) {
         self.get().encode(w, s);
@@ -174,31 +162,20 @@ impl<'a, S, A: for<'s> Decode<'a, 's, S>, B: for<'s> Decode<'a, 's, S>> Decode<'
     }
 }
 
-impl<S> Encode<S> for &[u8] {
-    fn encode(self, w: &mut Buffer, s: &mut S) {
-        self.len().encode(w, s);
-        w.write_all(self).unwrap();
-    }
-}
-
-impl<'a, S> Decode<'a, '_, S> for &'a [u8] {
-    fn decode(r: &mut &'a [u8], s: &mut S) -> Self {
-        let len = usize::decode(r, s);
-        let xs = &r[..len];
-        *r = &r[len..];
-        xs
-    }
-}
-
 impl<S> Encode<S> for &str {
     fn encode(self, w: &mut Buffer, s: &mut S) {
-        self.as_bytes().encode(w, s);
+        let bytes = self.as_bytes();
+        bytes.len().encode(w, s);
+        w.write_all(bytes).unwrap();
     }
 }
 
 impl<'a, S> Decode<'a, '_, S> for &'a str {
     fn decode(r: &mut &'a [u8], s: &mut S) -> Self {
-        str::from_utf8(<&[u8]>::decode(r, s)).unwrap()
+        let len = usize::decode(r, s);
+        let xs = &r[..len];
+        *r = &r[len..];
+        str::from_utf8(xs).unwrap()
     }
 }