Rollup merge of rust-lang#147497 - cyrgani:proc-macro-cleanups-3, r=petrochenkov

chenyukang · web-flow · commit 8c04cf0205de · 2025-10-14T09:08:48.000+08:00
`proc_macro` cleanups (3/N) Followup to rust-lang#147386, which removed the old `Decode` trait. Can be reviewed commit by commit.
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)),*
                 }
             }
         }
@@ -58,23 +58,18 @@ macro_rules! rpc_encode_decode {
             fn encode(self, w: &mut Writer, s: &mut S) {
                 // HACK(eddyb): `Tag` enum duplicated between the
                 // two impls as there's no other place to stash it.
-                #[allow(non_upper_case_globals)]
-                mod tag {
-                    #[repr(u8)] enum Tag { $($variant),* }
-
-                    $(pub(crate) const $variant: u8 = Tag::$variant as u8;)*
-                }
+                #[repr(u8)] enum Tag { $($variant),* }
 
                 match self {
                     $($name::$variant $(($field))* => {
-                        tag::$variant.encode(w, s);
+                        (Tag::$variant as u8).encode(w, s);
                         $($field.encode(w, s);)*
                     })*
                 }
             }
         }
 
-        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 {
@@ -89,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!(),
@@ -103,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 {}
 }
 
@@ -113,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..];
@@ -130,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,
@@ -146,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()
     }
@@ -158,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()
     }
@@ -171,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))
     }
 }
 
@@ -186,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];
@@ -201,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()
     }
@@ -213,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()
     }
@@ -228,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);
@@ -288,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/selfless_reify.rs b/library/proc_macro/src/bridge/selfless_reify.rs
@@ -50,7 +50,7 @@ macro_rules! define_reify_functions {
         >(f: F) -> $(extern $abi)? fn($($arg_ty),*) -> $ret_ty {
             // FIXME(eddyb) describe the `F` type (e.g. via `type_name::<F>`) once panic
             // formatting becomes possible in `const fn`.
-            assert!(size_of::<F>() == 0, "selfless_reify: closure must be zero-sized");
+            const { assert!(size_of::<F>() == 0, "selfless_reify: closure must be zero-sized"); }
 
             $(extern $abi)? fn wrapper<
                 $($($param,)*)?
diff --git a/library/proc_macro/src/bridge/server.rs b/library/proc_macro/src/bridge/server.rs
@@ -32,23 +32,23 @@ macro_rules! define_server_handles {
                 }
             }
 
-            impl<S: Types> DecodeMut<'_, '_, HandleStore<MarkedTypes<S>>>
+            impl<S: Types> Decode<'_, '_, HandleStore<MarkedTypes<S>>>
                 for Marked<S::$oty, client::$oty>
             {
                 fn decode(r: &mut Reader<'_>, s: &mut HandleStore<MarkedTypes<S>>) -> Self {
                     s.$oty.take(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 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`	`}`
`@@ -58,23 +58,18 @@ macro_rules! rpc_encode_decode {`
`58`	`58`	`fn encode(self, w: &mut Writer, s: &mut S) {`
`59`	`59`	// HACK(eddyb): `Tag` enum duplicated between the
`60`	`60`	`// two impls as there's no other place to stash it.`
`61`		`- #[allow(non_upper_case_globals)]`
`62`		`- mod tag {`
`63`		`- #[repr(u8)] enum Tag { $($variant),* }`
`64`		`-`
`65`		`- $(pub(crate) const $variant: u8 = Tag::$variant as u8;)*`
`66`		`- }`
	`61`	`+ #[repr(u8)] enum Tag { $($variant),* }`
`67`	`62`
`68`	`63`	`match self {`
`69`	`64`	`$($name::$variant $(($field))* => {`
`70`		`- tag::$variant.encode(w, s);`
	`65`	`+ (Tag::$variant as u8).encode(w, s);`
`71`	`66`	`$($field.encode(w, s);)*`
`72`	`67`	`})*`
`73`	`68`	`}`
`74`	`69`	`}`
`75`	`70`	`}`
`76`	`71`
`77`		`- 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>`
`78`	`73`	`for $name $(<$($T),+>)?`
`79`	`74`	`{`
`80`	`75`	`fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {`
`@@ -89,7 +84,7 @@ macro_rules! rpc_encode_decode {`
`89`	`84`
`90`	`85`	`match u8::decode(r, s) {`
`91`	`86`	`$(tag::$variant => {`
`92`		`- $(let $field = DecodeMut::decode(r, s);)*`
	`87`	`+ $(let $field = Decode::decode(r, s);)*`
`93`	`88`	`$name::$variant $(($field))*`
`94`	`89`	`})*`
`95`	`90`	`_ => unreachable!(),`
`@@ -103,7 +98,7 @@ impl<S> Encode<S> for () {`
`103`	`98`	`fn encode(self, _: &mut Writer, _: &mut S) {}`
`104`	`99`	`}`
`105`	`100`
`106`		`-impl<S> DecodeMut<'_, '_, S> for () {`
	`101`	`+impl<S> Decode<'_, '_, S> for () {`
`107`	`102`	`fn decode(_: &mut Reader<'_>, _: &mut S) -> Self {}`
`108`	`103`	`}`
`109`	`104`
`@@ -113,7 +108,7 @@ impl<S> Encode<S> for u8 {`
`113`	`108`	`}`
`114`	`109`	`}`
`115`	`110`
`116`		`-impl<S> DecodeMut<'_, '_, S> for u8 {`
	`111`	`+impl<S> Decode<'_, '_, S> for u8 {`
`117`	`112`	`fn decode(r: &mut Reader<'_>, _: &mut S) -> Self {`
`118`	`113`	`let x = r[0];`
`119`	`114`	`*r = &r[1..];`
`@@ -130,7 +125,7 @@ impl<S> Encode<S> for bool {`
`130`	`125`	`}`
`131`	`126`	`}`
`132`	`127`
`133`		`-impl<S> DecodeMut<'_, '_, S> for bool {`
	`128`	`+impl<S> Decode<'_, '_, S> for bool {`
`134`	`129`	`fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {`
`135`	`130`	`match u8::decode(r, s) {`
`136`	`131`	`0 => false,`
`@@ -146,7 +141,7 @@ impl<S> Encode<S> for char {`
`146`	`141`	`}`
`147`	`142`	`}`
`148`	`143`
`149`		`-impl<S> DecodeMut<'_, '_, S> for char {`
	`144`	`+impl<S> Decode<'_, '_, S> for char {`
`150`	`145`	`fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {`
`151`	`146`	`char::from_u32(u32::decode(r, s)).unwrap()`
`152`	`147`	`}`
`@@ -158,7 +153,7 @@ impl<S> Encode<S> for NonZero<u32> {`
`158`	`153`	`}`
`159`	`154`	`}`
`160`	`155`
`161`		`-impl<S> DecodeMut<'_, '_, S> for NonZero<u32> {`
	`156`	`+impl<S> Decode<'_, '_, S> for NonZero<u32> {`
`162`	`157`	`fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {`
`163`	`158`	`Self::new(u32::decode(r, s)).unwrap()`
`164`	`159`	`}`
`@@ -171,11 +166,11 @@ impl<S, A: Encode<S>, B: Encode<S>> Encode<S> for (A, B) {`
`171`	`166`	`}`
`172`	`167`	`}`
`173`	`168`
`174`		`-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>`
`175`	`170`	`for (A, B)`
`176`	`171`	`{`
`177`	`172`	`fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {`
`178`		`- (DecodeMut::decode(r, s), DecodeMut::decode(r, s))`
	`173`	`+ (Decode::decode(r, s), Decode::decode(r, s))`
`179`	`174`	`}`
`180`	`175`	`}`
`181`	`176`
`@@ -186,7 +181,7 @@ impl<S> Encode<S> for &[u8] {`
`186`	`181`	`}`
`187`	`182`	`}`
`188`	`183`
`189`		`-impl<'a, S> DecodeMut<'a, '_, S> for &'a [u8] {`
	`184`	`+impl<'a, S> Decode<'a, '_, S> for &'a [u8] {`
`190`	`185`	`fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {`
`191`	`186`	`let len = usize::decode(r, s);`
`192`	`187`	`let xs = &r[..len];`
`@@ -201,7 +196,7 @@ impl<S> Encode<S> for &str {`
`201`	`196`	`}`
`202`	`197`	`}`
`203`	`198`
`204`		`-impl<'a, S> DecodeMut<'a, '_, S> for &'a str {`
	`199`	`+impl<'a, S> Decode<'a, '_, S> for &'a str {`
`205`	`200`	`fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {`
`206`	`201`	`str::from_utf8(<&[u8]>::decode(r, s)).unwrap()`
`207`	`202`	`}`
`@@ -213,7 +208,7 @@ impl<S> Encode<S> for String {`
`213`	`208`	`}`
`214`	`209`	`}`
`215`	`210`
`216`		`-impl<S> DecodeMut<'_, '_, S> for String {`
	`211`	`+impl<S> Decode<'_, '_, S> for String {`
`217`	`212`	`fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {`
`218`	`213`	`<&str>::decode(r, s).to_string()`
`219`	`214`	`}`
`@@ -228,7 +223,7 @@ impl<S, T: Encode<S>> Encode<S> for Vec<T> {`
`228`	`223`	`}`
`229`	`224`	`}`
`230`	`225`
`231`		`-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> {`
`232`	`227`	`fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {`
`233`	`228`	`let len = usize::decode(r, s);`
`234`	`229`	`let mut vec = Vec::with_capacity(len);`
`@@ -288,7 +283,7 @@ impl<S> Encode<S> for PanicMessage {`
`288`	`283`	`}`
`289`	`284`	`}`
`290`	`285`
`291`		`-impl<S> DecodeMut<'_, '_, S> for PanicMessage {`
	`286`	`+impl<S> Decode<'_, '_, S> for PanicMessage {`
`292`	`287`	`fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {`
`293`	`288`	`match Option::<String>::decode(r, s) {`
`294`	`289`	`Some(s) => PanicMessage::String(s),`
Original file line number	Diff line number	Diff line change
`@@ -32,23 +32,23 @@ macro_rules! define_server_handles {`
`32`	`32`	`}`
`33`	`33`	`}`
`34`	`34`
`35`		`- impl<S: Types> DecodeMut<'_, '_, HandleStore<MarkedTypes<S>>>`
	`35`	`+ impl<S: Types> Decode<'_, '_, HandleStore<MarkedTypes<S>>>`
`36`	`36`	`for Marked<S::$oty, client::$oty>`
`37`	`37`	`{`
`38`	`38`	`fn decode(r: &mut Reader<'_>, s: &mut HandleStore<MarkedTypes<S>>) -> Self {`
`39`	`39`	`s.$oty.take(handle::Handle::decode(r, &mut ()))`
`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`	`}`