rename DecodeMut to Decode

cyrgani · cyrgani · commit 1cc575d02abb · 2025-10-08T21:39:50.000+02:00
diff --git a/library/proc_macro/src/bridge/client.rs b/library/proc_macro/src/bridge/client.rs
@@ -58,7 +58,7 @@ macro_rules! define_client_handles {
                 }
             }
 
-            impl<S> DecodeMut<'_, '_, S> for $oty {
+            impl<S> Decode<'_, '_, S> for $oty {
                 fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
                     $oty {
                         handle: handle::Handle::decode(r, s),
@@ -82,7 +82,7 @@ macro_rules! define_client_handles {
                 }
             }
 
-            impl<S> DecodeMut<'_, '_, S> for $ity {
+            impl<S> Decode<'_, '_, S> for $ity {
                 fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
                     $ity {
                         handle: handle::Handle::decode(r, s),
@@ -276,7 +276,7 @@ fn maybe_install_panic_hook(force_show_panics: bool) {
 /// Client-side helper for handling client panics, entering the bridge,
 /// deserializing input and serializing output.
 // FIXME(eddyb) maybe replace `Bridge::enter` with this?
-fn run_client<A: for<'a, 's> DecodeMut<'a, 's, ()>, R: Encode<()>>(
+fn run_client<A: for<'a, 's> Decode<'a, 's, ()>, R: Encode<()>>(
     config: BridgeConfig<'_>,
     f: impl FnOnce(A) -> R,
 ) -> Buffer {
diff --git a/library/proc_macro/src/bridge/mod.rs b/library/proc_macro/src/bridge/mod.rs
@@ -143,7 +143,7 @@ mod symbol;
 
 use buffer::Buffer;
 pub use rpc::PanicMessage;
-use rpc::{DecodeMut, Encode, Reader, Writer};
+use rpc::{Decode, Encode, Reader, Writer};
 
 /// Configuration for establishing an active connection between a server and a
 /// client.  The server creates the bridge config (`run_server` in `server.rs`),
@@ -168,7 +168,7 @@ impl !Sync for BridgeConfig<'_> {}
 #[forbid(unsafe_code)]
 #[allow(non_camel_case_types)]
 mod api_tags {
-    use super::rpc::{DecodeMut, Encode, Reader, Writer};
+    use super::rpc::{Decode, Encode, Reader, Writer};
 
     macro_rules! declare_tags {
         ($($name:ident {
diff --git a/library/proc_macro/src/bridge/rpc.rs b/library/proc_macro/src/bridge/rpc.rs
@@ -12,7 +12,7 @@ pub(super) trait Encode<S>: Sized {
 
 pub(super) type Reader<'a> = &'a [u8];
 
-pub(super) trait DecodeMut<'a, 's, S>: Sized {
+pub(super) trait Decode<'a, 's, S>: Sized {
     fn decode(r: &mut Reader<'a>, s: &'s mut S) -> Self;
 }
 
@@ -24,7 +24,7 @@ macro_rules! rpc_encode_decode {
             }
         }
 
-        impl<S> DecodeMut<'_, '_, S> for $ty {
+        impl<S> Decode<'_, '_, S> for $ty {
             fn decode(r: &mut Reader<'_>, _: &mut S) -> Self {
                 const N: usize = size_of::<$ty>();
 
@@ -43,12 +43,12 @@ macro_rules! rpc_encode_decode {
             }
         }
 
-        impl<'a, S, $($($T: for<'s> DecodeMut<'a, 's, S>),+)?> DecodeMut<'a, '_, S>
+        impl<'a, S, $($($T: for<'s> Decode<'a, 's, S>),+)?> Decode<'a, '_, S>
             for $name $(<$($T),+>)?
         {
             fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {
                 $name {
-                    $($field: DecodeMut::decode(r, s)),*
+                    $($field: Decode::decode(r, s)),*
                 }
             }
         }
@@ -69,7 +69,7 @@ macro_rules! rpc_encode_decode {
             }
         }
 
-        impl<'a, S, $($($T: for<'s> DecodeMut<'a, 's, S>),+)?> DecodeMut<'a, '_, S>
+        impl<'a, S, $($($T: for<'s> Decode<'a, 's, S>),+)?> Decode<'a, '_, S>
             for $name $(<$($T),+>)?
         {
             fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {
@@ -84,7 +84,7 @@ macro_rules! rpc_encode_decode {
 
                 match u8::decode(r, s) {
                     $(tag::$variant => {
-                        $(let $field = DecodeMut::decode(r, s);)*
+                        $(let $field = Decode::decode(r, s);)*
                         $name::$variant $(($field))*
                     })*
                     _ => unreachable!(),
@@ -98,7 +98,7 @@ impl<S> Encode<S> for () {
     fn encode(self, _: &mut Writer, _: &mut S) {}
 }
 
-impl<S> DecodeMut<'_, '_, S> for () {
+impl<S> Decode<'_, '_, S> for () {
     fn decode(_: &mut Reader<'_>, _: &mut S) -> Self {}
 }
 
@@ -108,7 +108,7 @@ impl<S> Encode<S> for u8 {
     }
 }
 
-impl<S> DecodeMut<'_, '_, S> for u8 {
+impl<S> Decode<'_, '_, S> for u8 {
     fn decode(r: &mut Reader<'_>, _: &mut S) -> Self {
         let x = r[0];
         *r = &r[1..];
@@ -125,7 +125,7 @@ impl<S> Encode<S> for bool {
     }
 }
 
-impl<S> DecodeMut<'_, '_, S> for bool {
+impl<S> Decode<'_, '_, S> for bool {
     fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
         match u8::decode(r, s) {
             0 => false,
@@ -141,7 +141,7 @@ impl<S> Encode<S> for char {
     }
 }
 
-impl<S> DecodeMut<'_, '_, S> for char {
+impl<S> Decode<'_, '_, S> for char {
     fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
         char::from_u32(u32::decode(r, s)).unwrap()
     }
@@ -153,7 +153,7 @@ impl<S> Encode<S> for NonZero<u32> {
     }
 }
 
-impl<S> DecodeMut<'_, '_, S> for NonZero<u32> {
+impl<S> Decode<'_, '_, S> for NonZero<u32> {
     fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
         Self::new(u32::decode(r, s)).unwrap()
     }
@@ -166,11 +166,11 @@ impl<S, A: Encode<S>, B: Encode<S>> Encode<S> for (A, B) {
     }
 }
 
-impl<'a, S, A: for<'s> DecodeMut<'a, 's, S>, B: for<'s> DecodeMut<'a, 's, S>> DecodeMut<'a, '_, S>
+impl<'a, S, A: for<'s> Decode<'a, 's, S>, B: for<'s> Decode<'a, 's, S>> Decode<'a, '_, S>
     for (A, B)
 {
     fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {
-        (DecodeMut::decode(r, s), DecodeMut::decode(r, s))
+        (Decode::decode(r, s), Decode::decode(r, s))
     }
 }
 
@@ -181,7 +181,7 @@ impl<S> Encode<S> for &[u8] {
     }
 }
 
-impl<'a, S> DecodeMut<'a, '_, S> for &'a [u8] {
+impl<'a, S> Decode<'a, '_, S> for &'a [u8] {
     fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {
         let len = usize::decode(r, s);
         let xs = &r[..len];
@@ -196,7 +196,7 @@ impl<S> Encode<S> for &str {
     }
 }
 
-impl<'a, S> DecodeMut<'a, '_, S> for &'a str {
+impl<'a, S> Decode<'a, '_, S> for &'a str {
     fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {
         str::from_utf8(<&[u8]>::decode(r, s)).unwrap()
     }
@@ -208,7 +208,7 @@ impl<S> Encode<S> for String {
     }
 }
 
-impl<S> DecodeMut<'_, '_, S> for String {
+impl<S> Decode<'_, '_, S> for String {
     fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
         <&str>::decode(r, s).to_string()
     }
@@ -223,7 +223,7 @@ impl<S, T: Encode<S>> Encode<S> for Vec<T> {
     }
 }
 
-impl<'a, S, T: for<'s> DecodeMut<'a, 's, S>> DecodeMut<'a, '_, S> for Vec<T> {
+impl<'a, S, T: for<'s> Decode<'a, 's, S>> Decode<'a, '_, S> for Vec<T> {
     fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {
         let len = usize::decode(r, s);
         let mut vec = Vec::with_capacity(len);
@@ -283,7 +283,7 @@ impl<S> Encode<S> for PanicMessage {
     }
 }
 
-impl<S> DecodeMut<'_, '_, S> for PanicMessage {
+impl<S> Decode<'_, '_, S> for PanicMessage {
     fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
         match Option::<String>::decode(r, s) {
             Some(s) => PanicMessage::String(s),
diff --git a/library/proc_macro/src/bridge/server.rs b/library/proc_macro/src/bridge/server.rs
@@ -40,15 +40,15 @@ macro_rules! define_server_handles {
                 }
             }
 
-            impl<'s, S: Types> DecodeMut<'_, 's, HandleStore<MarkedTypes<S>>>
+            impl<'s, S: Types> Decode<'_, 's, HandleStore<MarkedTypes<S>>>
                 for &'s Marked<S::$oty, client::$oty>
             {
                 fn decode(r: &mut Reader<'_>, s: &'s mut HandleStore<MarkedTypes<S>>) -> Self {
                     &s.$oty[handle::Handle::decode(r, &mut ())]
                 }
             }
 
-            impl<'s, S: Types> DecodeMut<'_, 's, HandleStore<MarkedTypes<S>>>
+            impl<'s, S: Types> Decode<'_, 's, HandleStore<MarkedTypes<S>>>
                 for &'s mut Marked<S::$oty, client::$oty>
             {
                 fn decode(
@@ -67,7 +67,7 @@ macro_rules! define_server_handles {
                 }
             }
 
-            impl<S: Types> DecodeMut<'_, '_, HandleStore<MarkedTypes<S>>>
+            impl<S: Types> Decode<'_, '_, HandleStore<MarkedTypes<S>>>
                 for Marked<S::$ity, client::$ity>
             {
                 fn decode(r: &mut Reader<'_>, s: &mut HandleStore<MarkedTypes<S>>) -> Self {
@@ -355,7 +355,7 @@ pub trait MessagePipe<T>: Sized {
 fn run_server<
     S: Server,
     I: Encode<HandleStore<MarkedTypes<S>>>,
-    O: for<'a, 's> DecodeMut<'a, 's, HandleStore<MarkedTypes<S>>>,
+    O: for<'a, 's> Decode<'a, 's, HandleStore<MarkedTypes<S>>>,
 >(
     strategy: &impl ExecutionStrategy,
     handle_counters: &'static client::HandleCounters,
diff --git a/library/proc_macro/src/bridge/symbol.rs b/library/proc_macro/src/bridge/symbol.rs
@@ -102,7 +102,7 @@ impl<S> Encode<S> for Symbol {
     }
 }
 
-impl<S: server::Server> DecodeMut<'_, '_, server::HandleStore<server::MarkedTypes<S>>>
+impl<S: server::Server> Decode<'_, '_, server::HandleStore<server::MarkedTypes<S>>>
     for Marked<S::Symbol, Symbol>
 {
     fn decode(r: &mut Reader<'_>, s: &mut server::HandleStore<server::MarkedTypes<S>>) -> Self {
@@ -118,7 +118,7 @@ impl<S: server::Server> Encode<server::HandleStore<server::MarkedTypes<S>>>
     }
 }
 
-impl<S> DecodeMut<'_, '_, S> for Symbol {
+impl<S> Decode<'_, '_, S> for Symbol {
     fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
         Symbol::new(<&str>::decode(r, s))
     }

Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ macro_rules! define_client_handles {`
`58`	`58`	`}`
`59`	`59`	`}`
`60`	`60`
`61`		`- impl<S> DecodeMut<'_, '_, S> for $oty {`
	`61`	`+ impl<S> Decode<'_, '_, S> for $oty {`
`62`	`62`	`fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {`
`63`	`63`	`$oty {`
`64`	`64`	`handle: handle::Handle::decode(r, s),`
`@@ -82,7 +82,7 @@ macro_rules! define_client_handles {`
`82`	`82`	`}`
`83`	`83`	`}`
`84`	`84`
`85`		`- impl<S> DecodeMut<'_, '_, S> for $ity {`
	`85`	`+ impl<S> Decode<'_, '_, S> for $ity {`
`86`	`86`	`fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {`
`87`	`87`	`$ity {`
`88`	`88`	`handle: handle::Handle::decode(r, s),`
`@@ -276,7 +276,7 @@ fn maybe_install_panic_hook(force_show_panics: bool) {`
`276`	`276`	`/// Client-side helper for handling client panics, entering the bridge,`
`277`	`277`	`/// deserializing input and serializing output.`
`278`	`278`	// FIXME(eddyb) maybe replace `Bridge::enter` with this?
`279`		`-fn run_client<A: for<'a, 's> DecodeMut<'a, 's, ()>, R: Encode<()>>(`
	`279`	`+fn run_client<A: for<'a, 's> Decode<'a, 's, ()>, R: Encode<()>>(`
`280`	`280`	`config: BridgeConfig<'_>,`
`281`	`281`	`f: impl FnOnce(A) -> R,`
`282`	`282`	`) -> Buffer {`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ pub(super) trait Encode<S>: Sized {`
`12`	`12`
`13`	`13`	`pub(super) type Reader<'a> = &'a [u8];`
`14`	`14`
`15`		`-pub(super) trait DecodeMut<'a, 's, S>: Sized {`
	`15`	`+pub(super) trait Decode<'a, 's, S>: Sized {`
`16`	`16`	`fn decode(r: &mut Reader<'a>, s: &'s mut S) -> Self;`
`17`	`17`	`}`
`18`	`18`
`@@ -24,7 +24,7 @@ macro_rules! rpc_encode_decode {`
`24`	`24`	`}`
`25`	`25`	`}`
`26`	`26`
`27`		`- impl<S> DecodeMut<'_, '_, S> for $ty {`
	`27`	`+ impl<S> Decode<'_, '_, S> for $ty {`
`28`	`28`	`fn decode(r: &mut Reader<'_>, _: &mut S) -> Self {`
`29`	`29`	`const N: usize = size_of::<$ty>();`
`30`	`30`
`@@ -43,12 +43,12 @@ macro_rules! rpc_encode_decode {`
`43`	`43`	`}`
`44`	`44`	`}`
`45`	`45`
`46`		`- impl<'a, S, $($($T: for<'s> DecodeMut<'a, 's, S>),+)?> DecodeMut<'a, '_, S>`
	`46`	`+ impl<'a, S, $($($T: for<'s> Decode<'a, 's, S>),+)?> Decode<'a, '_, S>`
`47`	`47`	`for $name $(<$($T),+>)?`
`48`	`48`	`{`
`49`	`49`	`fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {`
`50`	`50`	`$name {`
`51`		`- $($field: DecodeMut::decode(r, s)),*`
	`51`	`+ $($field: Decode::decode(r, s)),*`
`52`	`52`	`}`
`53`	`53`	`}`
`54`	`54`	`}`
`@@ -69,7 +69,7 @@ macro_rules! rpc_encode_decode {`
`69`	`69`	`}`
`70`	`70`	`}`
`71`	`71`
`72`		`- impl<'a, S, $($($T: for<'s> DecodeMut<'a, 's, S>),+)?> DecodeMut<'a, '_, S>`
	`72`	`+ impl<'a, S, $($($T: for<'s> Decode<'a, 's, S>),+)?> Decode<'a, '_, S>`
`73`	`73`	`for $name $(<$($T),+>)?`
`74`	`74`	`{`
`75`	`75`	`fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {`
`@@ -84,7 +84,7 @@ macro_rules! rpc_encode_decode {`
`84`	`84`
`85`	`85`	`match u8::decode(r, s) {`
`86`	`86`	`$(tag::$variant => {`
`87`		`- $(let $field = DecodeMut::decode(r, s);)*`
	`87`	`+ $(let $field = Decode::decode(r, s);)*`
`88`	`88`	`$name::$variant $(($field))*`
`89`	`89`	`})*`
`90`	`90`	`_ => unreachable!(),`
`@@ -98,7 +98,7 @@ impl<S> Encode<S> for () {`
`98`	`98`	`fn encode(self, _: &mut Writer, _: &mut S) {}`
`99`	`99`	`}`
`100`	`100`
`101`		`-impl<S> DecodeMut<'_, '_, S> for () {`
	`101`	`+impl<S> Decode<'_, '_, S> for () {`
`102`	`102`	`fn decode(_: &mut Reader<'_>, _: &mut S) -> Self {}`
`103`	`103`	`}`
`104`	`104`
`@@ -108,7 +108,7 @@ impl<S> Encode<S> for u8 {`
`108`	`108`	`}`
`109`	`109`	`}`
`110`	`110`
`111`		`-impl<S> DecodeMut<'_, '_, S> for u8 {`
	`111`	`+impl<S> Decode<'_, '_, S> for u8 {`
`112`	`112`	`fn decode(r: &mut Reader<'_>, _: &mut S) -> Self {`
`113`	`113`	`let x = r[0];`
`114`	`114`	`*r = &r[1..];`
`@@ -125,7 +125,7 @@ impl<S> Encode<S> for bool {`
`125`	`125`	`}`
`126`	`126`	`}`
`127`	`127`
`128`		`-impl<S> DecodeMut<'_, '_, S> for bool {`
	`128`	`+impl<S> Decode<'_, '_, S> for bool {`
`129`	`129`	`fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {`
`130`	`130`	`match u8::decode(r, s) {`
`131`	`131`	`0 => false,`
`@@ -141,7 +141,7 @@ impl<S> Encode<S> for char {`
`141`	`141`	`}`
`142`	`142`	`}`
`143`	`143`
`144`		`-impl<S> DecodeMut<'_, '_, S> for char {`
	`144`	`+impl<S> Decode<'_, '_, S> for char {`
`145`	`145`	`fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {`
`146`	`146`	`char::from_u32(u32::decode(r, s)).unwrap()`
`147`	`147`	`}`
`@@ -153,7 +153,7 @@ impl<S> Encode<S> for NonZero<u32> {`
`153`	`153`	`}`
`154`	`154`	`}`
`155`	`155`
`156`		`-impl<S> DecodeMut<'_, '_, S> for NonZero<u32> {`
	`156`	`+impl<S> Decode<'_, '_, S> for NonZero<u32> {`
`157`	`157`	`fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {`
`158`	`158`	`Self::new(u32::decode(r, s)).unwrap()`
`159`	`159`	`}`
`@@ -166,11 +166,11 @@ impl<S, A: Encode<S>, B: Encode<S>> Encode<S> for (A, B) {`
`166`	`166`	`}`
`167`	`167`	`}`
`168`	`168`
`169`		`-impl<'a, S, A: for<'s> DecodeMut<'a, 's, S>, B: for<'s> DecodeMut<'a, 's, S>> DecodeMut<'a, '_, S>`
	`169`	`+impl<'a, S, A: for<'s> Decode<'a, 's, S>, B: for<'s> Decode<'a, 's, S>> Decode<'a, '_, S>`
`170`	`170`	`for (A, B)`
`171`	`171`	`{`
`172`	`172`	`fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {`
`173`		`- (DecodeMut::decode(r, s), DecodeMut::decode(r, s))`
	`173`	`+ (Decode::decode(r, s), Decode::decode(r, s))`
`174`	`174`	`}`
`175`	`175`	`}`
`176`	`176`
`@@ -181,7 +181,7 @@ impl<S> Encode<S> for &[u8] {`
`181`	`181`	`}`
`182`	`182`	`}`
`183`	`183`
`184`		`-impl<'a, S> DecodeMut<'a, '_, S> for &'a [u8] {`
	`184`	`+impl<'a, S> Decode<'a, '_, S> for &'a [u8] {`
`185`	`185`	`fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {`
`186`	`186`	`let len = usize::decode(r, s);`
`187`	`187`	`let xs = &r[..len];`
`@@ -196,7 +196,7 @@ impl<S> Encode<S> for &str {`
`196`	`196`	`}`
`197`	`197`	`}`
`198`	`198`
`199`		`-impl<'a, S> DecodeMut<'a, '_, S> for &'a str {`
	`199`	`+impl<'a, S> Decode<'a, '_, S> for &'a str {`
`200`	`200`	`fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {`
`201`	`201`	`str::from_utf8(<&[u8]>::decode(r, s)).unwrap()`
`202`	`202`	`}`
`@@ -208,7 +208,7 @@ impl<S> Encode<S> for String {`
`208`	`208`	`}`
`209`	`209`	`}`
`210`	`210`
`211`		`-impl<S> DecodeMut<'_, '_, S> for String {`
	`211`	`+impl<S> Decode<'_, '_, S> for String {`
`212`	`212`	`fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {`
`213`	`213`	`<&str>::decode(r, s).to_string()`
`214`	`214`	`}`
`@@ -223,7 +223,7 @@ impl<S, T: Encode<S>> Encode<S> for Vec<T> {`
`223`	`223`	`}`
`224`	`224`	`}`
`225`	`225`
`226`		`-impl<'a, S, T: for<'s> DecodeMut<'a, 's, S>> DecodeMut<'a, '_, S> for Vec<T> {`
	`226`	`+impl<'a, S, T: for<'s> Decode<'a, 's, S>> Decode<'a, '_, S> for Vec<T> {`
`227`	`227`	`fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {`
`228`	`228`	`let len = usize::decode(r, s);`
`229`	`229`	`let mut vec = Vec::with_capacity(len);`
`@@ -283,7 +283,7 @@ impl<S> Encode<S> for PanicMessage {`
`283`	`283`	`}`
`284`	`284`	`}`
`285`	`285`
`286`		`-impl<S> DecodeMut<'_, '_, S> for PanicMessage {`
	`286`	`+impl<S> Decode<'_, '_, S> for PanicMessage {`
`287`	`287`	`fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {`
`288`	`288`	`match Option::<String>::decode(r, s) {`
`289`	`289`	`Some(s) => PanicMessage::String(s),`
Original file line number	Diff line number	Diff line change
`@@ -40,15 +40,15 @@ macro_rules! define_server_handles {`
`40`	`40`	`}`
`41`	`41`	`}`
`42`	`42`
`43`		`- impl<'s, S: Types> DecodeMut<'_, 's, HandleStore<MarkedTypes<S>>>`
	`43`	`+ impl<'s, S: Types> Decode<'_, 's, HandleStore<MarkedTypes<S>>>`
`44`	`44`	`for &'s Marked<S::$oty, client::$oty>`
`45`	`45`	`{`
`46`	`46`	`fn decode(r: &mut Reader<'_>, s: &'s mut HandleStore<MarkedTypes<S>>) -> Self {`
`47`	`47`	`&s.$oty[handle::Handle::decode(r, &mut ())]`
`48`	`48`	`}`
`49`	`49`	`}`
`50`	`50`
`51`		`- impl<'s, S: Types> DecodeMut<'_, 's, HandleStore<MarkedTypes<S>>>`
	`51`	`+ impl<'s, S: Types> Decode<'_, 's, HandleStore<MarkedTypes<S>>>`
`52`	`52`	`for &'s mut Marked<S::$oty, client::$oty>`
`53`	`53`	`{`
`54`	`54`	`fn decode(`
`@@ -67,7 +67,7 @@ macro_rules! define_server_handles {`
`67`	`67`	`}`
`68`	`68`	`}`
`69`	`69`
`70`		`- impl<S: Types> DecodeMut<'_, '_, HandleStore<MarkedTypes<S>>>`
	`70`	`+ impl<S: Types> Decode<'_, '_, HandleStore<MarkedTypes<S>>>`
`71`	`71`	`for Marked<S::$ity, client::$ity>`
`72`	`72`	`{`
`73`	`73`	`fn decode(r: &mut Reader<'_>, s: &mut HandleStore<MarkedTypes<S>>) -> Self {`
`@@ -355,7 +355,7 @@ pub trait MessagePipe<T>: Sized {`
`355`	`355`	`fn run_server<`
`356`	`356`	`S: Server,`
`357`	`357`	`I: Encode<HandleStore<MarkedTypes<S>>>,`
`358`		`- O: for<'a, 's> DecodeMut<'a, 's, HandleStore<MarkedTypes<S>>>,`
	`358`	`+ O: for<'a, 's> Decode<'a, 's, HandleStore<MarkedTypes<S>>>,`
`359`	`359`	`>(`
`360`	`360`	`strategy: &impl ExecutionStrategy,`
`361`	`361`	`handle_counters: &'static client::HandleCounters,`
Original file line number	Diff line number	Diff line change
`@@ -102,7 +102,7 @@ impl<S> Encode<S> for Symbol {`
`102`	`102`	`}`
`103`	`103`	`}`
`104`	`104`
`105`		`-impl<S: server::Server> DecodeMut<'_, '_, server::HandleStore<server::MarkedTypes<S>>>`
	`105`	`+impl<S: server::Server> Decode<'_, '_, server::HandleStore<server::MarkedTypes<S>>>`
`106`	`106`	`for Marked<S::Symbol, Symbol>`
`107`	`107`	`{`
`108`	`108`	`fn decode(r: &mut Reader<'_>, s: &mut server::HandleStore<server::MarkedTypes<S>>) -> Self {`
`@@ -118,7 +118,7 @@ impl<S: server::Server> Encode<server::HandleStore<server::MarkedTypes<S>>>`
`118`	`118`	`}`
`119`	`119`	`}`
`120`	`120`
`121`		`-impl<S> DecodeMut<'_, '_, S> for Symbol {`
	`121`	`+impl<S> Decode<'_, '_, S> for Symbol {`
`122`	`122`	`fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {`
`123`	`123`	`Symbol::new(<&str>::decode(r, s))`
`124`	`124`	`}`