Rollup merge of #157450 - cyrgani:pm-inline, r=petrochenkov

jhpratt · web-flow · commit 5fba2b7f328e · 2026-06-05T15:18:51.000-04:00
mark `Encode`, `Decode`, `Mark` impls as `#[inline]` Related to #157271 (though it was not a part of it). This looked pretty promising locally.
diff --git a/library/proc_macro/src/bridge/client.rs b/library/proc_macro/src/bridge/client.rs
@@ -20,30 +20,35 @@ impl Drop for TokenStream {
 }
 
 impl<S> Encode<S> for TokenStream {
+    #[inline]
     fn encode(self, w: &mut Buffer, s: &mut S) {
         mem::ManuallyDrop::new(self).handle.encode(w, s);
     }
 }
 
 impl<S> Encode<S> for &TokenStream {
+    #[inline]
     fn encode(self, w: &mut Buffer, s: &mut S) {
         self.handle.encode(w, s);
     }
 }
 
 impl<S> Decode<'_, '_, S> for TokenStream {
+    #[inline]
     fn decode(r: &mut &[u8], s: &mut S) -> Self {
         TokenStream { handle: handle::Handle::decode(r, s) }
     }
 }
 
 impl Encode<()> for crate::TokenStream {
+    #[inline]
     fn encode(self, w: &mut Buffer, s: &mut ()) {
         self.0.encode(w, s)
     }
 }
 
 impl Decode<'_, '_, ()> for crate::TokenStream {
+    #[inline]
     fn decode(r: &mut &[u8], s: &mut ()) -> Self {
         crate::TokenStream(Some(Decode::decode(r, s)))
     }
@@ -58,12 +63,14 @@ impl !Send for Span {}
 impl !Sync for Span {}
 
 impl<S> Encode<S> for Span {
+    #[inline]
     fn encode(self, w: &mut Buffer, s: &mut S) {
         self.handle.encode(w, s);
     }
 }
 
 impl<S> Decode<'_, '_, S> for Span {
+    #[inline]
     fn decode(r: &mut &[u8], s: &mut S) -> Self {
         Span { handle: handle::Handle::decode(r, s) }
     }
diff --git a/library/proc_macro/src/bridge/mod.rs b/library/proc_macro/src/bridge/mod.rs
@@ -162,9 +162,11 @@ struct Marked<T, M> {
 
 impl<T, M> Mark for Marked<T, M> {
     type Unmarked = T;
+    #[inline]
     fn mark(unmarked: Self::Unmarked) -> Self {
         Marked { value: unmarked, _marker: marker::PhantomData }
     }
+    #[inline]
     fn unmark(self) -> Self::Unmarked {
         self.value
     }
@@ -174,17 +176,20 @@ impl<'a, T> Mark for &'a Marked<T, client::TokenStream> {
     fn mark(_: Self::Unmarked) -> Self {
         unreachable!()
     }
+    #[inline]
     fn unmark(self) -> Self::Unmarked {
         &self.value
     }
 }
 
 impl<T: Mark> Mark for Vec<T> {
     type Unmarked = Vec<T::Unmarked>;
+    #[inline]
     fn mark(unmarked: Self::Unmarked) -> Self {
         // Should be a no-op due to std's in-place collect optimizations.
         unmarked.into_iter().map(T::mark).collect()
     }
+    #[inline]
     fn unmark(self) -> Self::Unmarked {
         // Should be a no-op due to std's in-place collect optimizations.
         self.into_iter().map(T::unmark).collect()
@@ -196,9 +201,11 @@ macro_rules! mark_noop {
         $(
             impl Mark for $ty {
                 type Unmarked = Self;
+                #[inline]
                 fn mark(unmarked: Self::Unmarked) -> Self {
                     unmarked
                 }
+                #[inline]
                 fn unmark(self) -> Self::Unmarked {
                     self
                 }
@@ -276,11 +283,13 @@ macro_rules! mark_compound {
     (struct $name:ident <$($T:ident),+> { $($field:ident),* $(,)? }) => {
         impl<$($T: Mark),+> Mark for $name <$($T),+> {
             type Unmarked = $name <$($T::Unmarked),+>;
+            #[inline]
             fn mark(unmarked: Self::Unmarked) -> Self {
                 $name {
                     $($field: Mark::mark(unmarked.$field)),*
                 }
             }
+            #[inline]
             fn unmark(self) -> Self::Unmarked {
                 $name {
                     $($field: Mark::unmark(self.$field)),*
@@ -291,13 +300,15 @@ macro_rules! mark_compound {
     (enum $name:ident <$($T:ident),+> { $($variant:ident $(($field:ident))?),* $(,)? }) => {
         impl<$($T: Mark),+> Mark for $name <$($T),+> {
             type Unmarked = $name <$($T::Unmarked),+>;
+            #[inline]
             fn mark(unmarked: Self::Unmarked) -> Self {
                 match unmarked {
                     $($name::$variant $(($field))? => {
                         $name::$variant $((Mark::mark($field)))?
                     })*
                 }
             }
+            #[inline]
             fn unmark(self) -> Self::Unmarked {
                 match self {
                     $($name::$variant $(($field))? => {
diff --git a/library/proc_macro/src/bridge/rpc.rs b/library/proc_macro/src/bridge/rpc.rs
@@ -17,12 +17,14 @@ pub(super) trait Decode<'a, 's, S>: Sized {
 macro_rules! rpc_encode_decode {
     (le $ty:ty) => {
         impl<S> Encode<S> for $ty {
+            #[inline]
             fn encode(self, w: &mut Buffer, _: &mut S) {
                 w.extend_from_array(&self.to_le_bytes());
             }
         }
 
         impl<S> Decode<'_, '_, S> for $ty {
+            #[inline]
             fn decode(r: &mut &[u8], _: &mut S) -> Self {
                 const N: usize = size_of::<$ty>();
 
@@ -44,6 +46,7 @@ macro_rules! rpc_encode_decode {
         impl<'a, S, $($($T: for<'s> Decode<'a, 's, S>),+)?> Decode<'a, '_, S>
             for $name $(<$($T),+>)?
         {
+            #[inline]
             fn decode(r: &mut &'a [u8], s: &mut S) -> Self {
                 $name {
                     $($field: Decode::decode(r, s)),*
@@ -59,6 +62,7 @@ macro_rules! rpc_encode_decode {
             $(const $variant: u8 = Tag::$variant as u8;)*
 
             impl<S, $($($T: Encode<S>),+)?> Encode<S> for $name $(<$($T),+>)? {
+                #[inline]
                 fn encode(self, w: &mut Buffer, s: &mut S) {
                     match self {
                         $($name::$variant $(($field))* => {
@@ -72,6 +76,7 @@ macro_rules! rpc_encode_decode {
             impl<'a, S, $($($T: for<'s> Decode<'a, 's, S>),+)?> Decode<'a, '_, S>
                 for $name $(<$($T),+>)?
             {
+                #[inline]
                 fn decode(r: &mut &'a [u8], s: &mut S) -> Self {
                     match u8::decode(r, s) {
                         $($variant => {
@@ -87,20 +92,24 @@ macro_rules! rpc_encode_decode {
 }
 
 impl<S> Encode<S> for () {
+    #[inline]
     fn encode(self, _: &mut Buffer, _: &mut S) {}
 }
 
 impl<S> Decode<'_, '_, S> for () {
+    #[inline]
     fn decode(_: &mut &[u8], _: &mut S) -> Self {}
 }
 
 impl<S> Encode<S> for u8 {
+    #[inline]
     fn encode(self, w: &mut Buffer, _: &mut S) {
         w.push(self);
     }
 }
 
 impl<S> Decode<'_, '_, S> for u8 {
+    #[inline]
     fn decode(r: &mut &[u8], _: &mut S) -> Self {
         let x = r[0];
         *r = &r[1..];
@@ -117,6 +126,7 @@ const MAX_USIZE_SIZE: usize = 8;
 
 #[cfg(not(target_pointer_width = "64"))]
 impl<S> Encode<S> for usize {
+    #[inline]
     fn encode(self, w: &mut Buffer, _: &mut S) {
         const N: usize = size_of::<usize>();
 
@@ -131,6 +141,7 @@ impl<S> Encode<S> for usize {
 
 #[cfg(not(target_pointer_width = "64"))]
 impl<S> Decode<'_, '_, S> for usize {
+    #[inline]
     fn decode(r: &mut &[u8], _: &mut S) -> Self {
         const N: usize = size_of::<usize>();
         const {
@@ -146,12 +157,14 @@ impl<S> Decode<'_, '_, S> for usize {
 }
 
 impl<S> Encode<S> for bool {
+    #[inline]
     fn encode(self, w: &mut Buffer, s: &mut S) {
         (self as u8).encode(w, s);
     }
 }
 
 impl<S> Decode<'_, '_, S> for bool {
+    #[inline]
     fn decode(r: &mut &[u8], s: &mut S) -> Self {
         match u8::decode(r, s) {
             0 => false,
@@ -162,18 +175,21 @@ impl<S> Decode<'_, '_, S> for bool {
 }
 
 impl<S> Encode<S> for NonZero<u32> {
+    #[inline]
     fn encode(self, w: &mut Buffer, s: &mut S) {
         self.get().encode(w, s);
     }
 }
 
 impl<S> Decode<'_, '_, S> for NonZero<u32> {
+    #[inline]
     fn decode(r: &mut &[u8], s: &mut S) -> Self {
         Self::new(u32::decode(r, s)).unwrap()
     }
 }
 
 impl<S, A: Encode<S>, B: Encode<S>> Encode<S> for (A, B) {
+    #[inline]
     fn encode(self, w: &mut Buffer, s: &mut S) {
         self.0.encode(w, s);
         self.1.encode(w, s);
@@ -183,12 +199,14 @@ impl<S, A: Encode<S>, B: Encode<S>> Encode<S> for (A, B) {
 impl<'a, S, A: for<'s> Decode<'a, 's, S>, B: for<'s> Decode<'a, 's, S>> Decode<'a, '_, S>
     for (A, B)
 {
+    #[inline]
     fn decode(r: &mut &'a [u8], s: &mut S) -> Self {
         (Decode::decode(r, s), Decode::decode(r, s))
     }
 }
 
 impl<S> Encode<S> for &str {
+    #[inline]
     fn encode(self, w: &mut Buffer, s: &mut S) {
         let bytes = self.as_bytes();
         bytes.len().encode(w, s);
@@ -197,6 +215,7 @@ impl<S> Encode<S> for &str {
 }
 
 impl<'a, S> Decode<'a, '_, S> for &'a str {
+    #[inline]
     fn decode(r: &mut &'a [u8], s: &mut S) -> Self {
         let len = usize::decode(r, s);
         let xs = &r[..len];
@@ -206,18 +225,21 @@ impl<'a, S> Decode<'a, '_, S> for &'a str {
 }
 
 impl<S> Encode<S> for String {
+    #[inline]
     fn encode(self, w: &mut Buffer, s: &mut S) {
         self[..].encode(w, s);
     }
 }
 
 impl<S> Decode<'_, '_, S> for String {
+    #[inline]
     fn decode(r: &mut &[u8], s: &mut S) -> Self {
         <&str>::decode(r, s).to_string()
     }
 }
 
 impl<S, T: Encode<S>> Encode<S> for Vec<T> {
+    #[inline]
     fn encode(self, w: &mut Buffer, s: &mut S) {
         self.len().encode(w, s);
         for x in self {
@@ -227,6 +249,7 @@ impl<S, T: Encode<S>> Encode<S> for Vec<T> {
 }
 
 impl<'a, S, T: for<'s> Decode<'a, 's, S>> Decode<'a, '_, S> for Vec<T> {
+    #[inline]
     fn decode(r: &mut &'a [u8], s: &mut S) -> Self {
         let len = usize::decode(r, s);
         let mut vec = Vec::with_capacity(len);
@@ -289,12 +312,14 @@ impl PanicMessage {
 }
 
 impl<S> Encode<S> for PanicMessage {
+    #[inline]
     fn encode(self, w: &mut Buffer, s: &mut S) {
         self.as_str().encode(w, s);
     }
 }
 
 impl<S> Decode<'_, '_, S> for PanicMessage {
+    #[inline]
     fn decode(r: &mut &[u8], s: &mut S) -> Self {
         match Option::<String>::decode(r, s) {
             Some(s) => PanicMessage::String(s),

Original file line number	Diff line number	Diff line change
`@@ -20,30 +20,35 @@ impl Drop for TokenStream {`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`impl<S> Encode<S> for TokenStream {`
	`23`	`+ #[inline]`
`23`	`24`	`fn encode(self, w: &mut Buffer, s: &mut S) {`
`24`	`25`	`mem::ManuallyDrop::new(self).handle.encode(w, s);`
`25`	`26`	`}`
`26`	`27`	`}`
`27`	`28`
`28`	`29`	`impl<S> Encode<S> for &TokenStream {`
	`30`	`+ #[inline]`
`29`	`31`	`fn encode(self, w: &mut Buffer, s: &mut S) {`
`30`	`32`	`self.handle.encode(w, s);`
`31`	`33`	`}`
`32`	`34`	`}`
`33`	`35`
`34`	`36`	`impl<S> Decode<'_, '_, S> for TokenStream {`
	`37`	`+ #[inline]`
`35`	`38`	`fn decode(r: &mut &[u8], s: &mut S) -> Self {`
`36`	`39`	`TokenStream { handle: handle::Handle::decode(r, s) }`
`37`	`40`	`}`
`38`	`41`	`}`
`39`	`42`
`40`	`43`	`impl Encode<()> for crate::TokenStream {`
	`44`	`+ #[inline]`
`41`	`45`	`fn encode(self, w: &mut Buffer, s: &mut ()) {`
`42`	`46`	`self.0.encode(w, s)`
`43`	`47`	`}`
`44`	`48`	`}`
`45`	`49`
`46`	`50`	`impl Decode<'_, '_, ()> for crate::TokenStream {`
	`51`	`+ #[inline]`
`47`	`52`	`fn decode(r: &mut &[u8], s: &mut ()) -> Self {`
`48`	`53`	`crate::TokenStream(Some(Decode::decode(r, s)))`
`49`	`54`	`}`
`@@ -58,12 +63,14 @@ impl !Send for Span {}`
`58`	`63`	`impl !Sync for Span {}`
`59`	`64`
`60`	`65`	`impl<S> Encode<S> for Span {`
	`66`	`+ #[inline]`
`61`	`67`	`fn encode(self, w: &mut Buffer, s: &mut S) {`
`62`	`68`	`self.handle.encode(w, s);`
`63`	`69`	`}`
`64`	`70`	`}`
`65`	`71`
`66`	`72`	`impl<S> Decode<'_, '_, S> for Span {`
	`73`	`+ #[inline]`
`67`	`74`	`fn decode(r: &mut &[u8], s: &mut S) -> Self {`
`68`	`75`	`Span { handle: handle::Handle::decode(r, s) }`
`69`	`76`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,12 +17,14 @@ pub(super) trait Decode<'a, 's, S>: Sized {`
`17`	`17`	`macro_rules! rpc_encode_decode {`
`18`	`18`	`(le $ty:ty) => {`
`19`	`19`	`impl<S> Encode<S> for $ty {`
	`20`	`+ #[inline]`
`20`	`21`	`fn encode(self, w: &mut Buffer, _: &mut S) {`
`21`	`22`	`w.extend_from_array(&self.to_le_bytes());`
`22`	`23`	`}`
`23`	`24`	`}`
`24`	`25`
`25`	`26`	`impl<S> Decode<'_, '_, S> for $ty {`
	`27`	`+ #[inline]`
`26`	`28`	`fn decode(r: &mut &[u8], _: &mut S) -> Self {`
`27`	`29`	`const N: usize = size_of::<$ty>();`
`28`	`30`
`@@ -44,6 +46,7 @@ macro_rules! rpc_encode_decode {`
`44`	`46`	`impl<'a, S, $($($T: for<'s> Decode<'a, 's, S>),+)?> Decode<'a, '_, S>`
`45`	`47`	`for $name $(<$($T),+>)?`
`46`	`48`	`{`
	`49`	`+ #[inline]`
`47`	`50`	`fn decode(r: &mut &'a [u8], s: &mut S) -> Self {`
`48`	`51`	`$name {`
`49`	`52`	`$($field: Decode::decode(r, s)),*`
`@@ -59,6 +62,7 @@ macro_rules! rpc_encode_decode {`
`59`	`62`	`$(const $variant: u8 = Tag::$variant as u8;)*`
`60`	`63`
`61`	`64`	`impl<S, $($($T: Encode<S>),+)?> Encode<S> for $name $(<$($T),+>)? {`
	`65`	`+ #[inline]`
`62`	`66`	`fn encode(self, w: &mut Buffer, s: &mut S) {`
`63`	`67`	`match self {`
`64`	`68`	`$($name::$variant $(($field))* => {`
`@@ -72,6 +76,7 @@ macro_rules! rpc_encode_decode {`
`72`	`76`	`impl<'a, S, $($($T: for<'s> Decode<'a, 's, S>),+)?> Decode<'a, '_, S>`
`73`	`77`	`for $name $(<$($T),+>)?`
`74`	`78`	`{`
	`79`	`+ #[inline]`
`75`	`80`	`fn decode(r: &mut &'a [u8], s: &mut S) -> Self {`
`76`	`81`	`match u8::decode(r, s) {`
`77`	`82`	`$($variant => {`
`@@ -87,20 +92,24 @@ macro_rules! rpc_encode_decode {`
`87`	`92`	`}`
`88`	`93`
`89`	`94`	`impl<S> Encode<S> for () {`
	`95`	`+ #[inline]`
`90`	`96`	`fn encode(self, _: &mut Buffer, _: &mut S) {}`
`91`	`97`	`}`
`92`	`98`
`93`	`99`	`impl<S> Decode<'_, '_, S> for () {`
	`100`	`+ #[inline]`
`94`	`101`	`fn decode(_: &mut &[u8], _: &mut S) -> Self {}`
`95`	`102`	`}`
`96`	`103`
`97`	`104`	`impl<S> Encode<S> for u8 {`
	`105`	`+ #[inline]`
`98`	`106`	`fn encode(self, w: &mut Buffer, _: &mut S) {`
`99`	`107`	`w.push(self);`
`100`	`108`	`}`
`101`	`109`	`}`
`102`	`110`
`103`	`111`	`impl<S> Decode<'_, '_, S> for u8 {`
	`112`	`+ #[inline]`
`104`	`113`	`fn decode(r: &mut &[u8], _: &mut S) -> Self {`
`105`	`114`	`let x = r[0];`
`106`	`115`	`*r = &r[1..];`
`@@ -117,6 +126,7 @@ const MAX_USIZE_SIZE: usize = 8;`
`117`	`126`
`118`	`127`	`#[cfg(not(target_pointer_width = "64"))]`
`119`	`128`	`impl<S> Encode<S> for usize {`
	`129`	`+ #[inline]`
`120`	`130`	`fn encode(self, w: &mut Buffer, _: &mut S) {`
`121`	`131`	`const N: usize = size_of::<usize>();`
`122`	`132`
`@@ -131,6 +141,7 @@ impl<S> Encode<S> for usize {`
`131`	`141`
`132`	`142`	`#[cfg(not(target_pointer_width = "64"))]`
`133`	`143`	`impl<S> Decode<'_, '_, S> for usize {`
	`144`	`+ #[inline]`
`134`	`145`	`fn decode(r: &mut &[u8], _: &mut S) -> Self {`
`135`	`146`	`const N: usize = size_of::<usize>();`
`136`	`147`	`const {`
`@@ -146,12 +157,14 @@ impl<S> Decode<'_, '_, S> for usize {`
`146`	`157`	`}`
`147`	`158`
`148`	`159`	`impl<S> Encode<S> for bool {`
	`160`	`+ #[inline]`
`149`	`161`	`fn encode(self, w: &mut Buffer, s: &mut S) {`
`150`	`162`	`(self as u8).encode(w, s);`
`151`	`163`	`}`
`152`	`164`	`}`
`153`	`165`
`154`	`166`	`impl<S> Decode<'_, '_, S> for bool {`
	`167`	`+ #[inline]`
`155`	`168`	`fn decode(r: &mut &[u8], s: &mut S) -> Self {`
`156`	`169`	`match u8::decode(r, s) {`
`157`	`170`	`0 => false,`
`@@ -162,18 +175,21 @@ impl<S> Decode<'_, '_, S> for bool {`
`162`	`175`	`}`
`163`	`176`
`164`	`177`	`impl<S> Encode<S> for NonZero<u32> {`
	`178`	`+ #[inline]`
`165`	`179`	`fn encode(self, w: &mut Buffer, s: &mut S) {`
`166`	`180`	`self.get().encode(w, s);`
`167`	`181`	`}`
`168`	`182`	`}`
`169`	`183`
`170`	`184`	`impl<S> Decode<'_, '_, S> for NonZero<u32> {`
	`185`	`+ #[inline]`
`171`	`186`	`fn decode(r: &mut &[u8], s: &mut S) -> Self {`
`172`	`187`	`Self::new(u32::decode(r, s)).unwrap()`
`173`	`188`	`}`
`174`	`189`	`}`
`175`	`190`
`176`	`191`	`impl<S, A: Encode<S>, B: Encode<S>> Encode<S> for (A, B) {`
	`192`	`+ #[inline]`
`177`	`193`	`fn encode(self, w: &mut Buffer, s: &mut S) {`
`178`	`194`	`self.0.encode(w, s);`
`179`	`195`	`self.1.encode(w, s);`
`@@ -183,12 +199,14 @@ impl<S, A: Encode<S>, B: Encode<S>> Encode<S> for (A, B) {`
`183`	`199`	`impl<'a, S, A: for<'s> Decode<'a, 's, S>, B: for<'s> Decode<'a, 's, S>> Decode<'a, '_, S>`
`184`	`200`	`for (A, B)`
`185`	`201`	`{`
	`202`	`+ #[inline]`
`186`	`203`	`fn decode(r: &mut &'a [u8], s: &mut S) -> Self {`
`187`	`204`	`(Decode::decode(r, s), Decode::decode(r, s))`
`188`	`205`	`}`
`189`	`206`	`}`
`190`	`207`
`191`	`208`	`impl<S> Encode<S> for &str {`
	`209`	`+ #[inline]`
`192`	`210`	`fn encode(self, w: &mut Buffer, s: &mut S) {`
`193`	`211`	`let bytes = self.as_bytes();`
`194`	`212`	`bytes.len().encode(w, s);`
`@@ -197,6 +215,7 @@ impl<S> Encode<S> for &str {`
`197`	`215`	`}`
`198`	`216`
`199`	`217`	`impl<'a, S> Decode<'a, '_, S> for &'a str {`
	`218`	`+ #[inline]`
`200`	`219`	`fn decode(r: &mut &'a [u8], s: &mut S) -> Self {`
`201`	`220`	`let len = usize::decode(r, s);`
`202`	`221`	`let xs = &r[..len];`
`@@ -206,18 +225,21 @@ impl<'a, S> Decode<'a, '_, S> for &'a str {`
`206`	`225`	`}`
`207`	`226`
`208`	`227`	`impl<S> Encode<S> for String {`
	`228`	`+ #[inline]`
`209`	`229`	`fn encode(self, w: &mut Buffer, s: &mut S) {`
`210`	`230`	`self[..].encode(w, s);`
`211`	`231`	`}`
`212`	`232`	`}`
`213`	`233`
`214`	`234`	`impl<S> Decode<'_, '_, S> for String {`
	`235`	`+ #[inline]`
`215`	`236`	`fn decode(r: &mut &[u8], s: &mut S) -> Self {`
`216`	`237`	`<&str>::decode(r, s).to_string()`
`217`	`238`	`}`
`218`	`239`	`}`
`219`	`240`
`220`	`241`	`impl<S, T: Encode<S>> Encode<S> for Vec<T> {`
	`242`	`+ #[inline]`
`221`	`243`	`fn encode(self, w: &mut Buffer, s: &mut S) {`
`222`	`244`	`self.len().encode(w, s);`
`223`	`245`	`for x in self {`
`@@ -227,6 +249,7 @@ impl<S, T: Encode<S>> Encode<S> for Vec<T> {`
`227`	`249`	`}`
`228`	`250`
`229`	`251`	`impl<'a, S, T: for<'s> Decode<'a, 's, S>> Decode<'a, '_, S> for Vec<T> {`
	`252`	`+ #[inline]`
`230`	`253`	`fn decode(r: &mut &'a [u8], s: &mut S) -> Self {`
`231`	`254`	`let len = usize::decode(r, s);`
`232`	`255`	`let mut vec = Vec::with_capacity(len);`
`@@ -289,12 +312,14 @@ impl PanicMessage {`
`289`	`312`	`}`
`290`	`313`
`291`	`314`	`impl<S> Encode<S> for PanicMessage {`
	`315`	`+ #[inline]`
`292`	`316`	`fn encode(self, w: &mut Buffer, s: &mut S) {`
`293`	`317`	`self.as_str().encode(w, s);`
`294`	`318`	`}`
`295`	`319`	`}`
`296`	`320`
`297`	`321`	`impl<S> Decode<'_, '_, S> for PanicMessage {`
	`322`	`+ #[inline]`
`298`	`323`	`fn decode(r: &mut &[u8], s: &mut S) -> Self {`
`299`	`324`	`match Option::<String>::decode(r, s) {`
`300`	`325`	`Some(s) => PanicMessage::String(s),`