add #[inline] attribute to many text::Reader and text::Builder methods

The idea here is to lower the likelihood of any performance degradation
caused by the changes in the 0.18 release.

Author: dwrensha

capnp/src/text.rs

@@ -67,12 +67,14 @@ impl<'a> core::fmt::Debug for Reader<'a> {
 }
 
 impl<'a> From<&'a str> for Reader<'a> {
+    #[inline]
     fn from(value: &'a str) -> Self {
         Self(value.as_bytes())
     }
 }
 
 impl<'a> From<&'a [u8]> for Reader<'a> {
+    #[inline]
     fn from(value: &'a [u8]) -> Self {
         Self(value)
     }
@@ -103,27 +105,32 @@ impl<'a> crate::traits::FromPointerReader<'a> for Reader<'a> {
 
 impl<'a> Reader<'a> {
     /// The string's length, in bytes.
+    #[inline]
     pub fn len(&self) -> usize {
         self.as_bytes().len()
     }
 
+    #[inline]
     pub fn is_empty(&self) -> bool {
         self.len() == 0
     }
 
+    #[inline]
     pub fn as_bytes(self) -> &'a [u8] {
         let Self(d) = self;
         d
     }
 
     /// Converts to a `str`, returning a error if the data contains invalid utf-8.
+    #[inline]
     pub fn to_str(self) -> core::result::Result<&'a str, core::str::Utf8Error> {
         let Self(s) = self;
         str::from_utf8(s)
     }
 
     #[cfg(feature = "alloc")]
     /// Converts to a `String`, returning a error if the data contains invalid utf-8.
+    #[inline]
     pub fn to_string(self) -> core::result::Result<alloc::string::String, core::str::Utf8Error> {
         Ok(self.to_str()?.into())
     }
@@ -156,50 +163,60 @@ impl<'a> core::cmp::PartialEq<Builder<'a>> for &'a str {
 }
 
 impl<'a> Builder<'a> {
+    #[inline]
     pub fn new(bytes: &mut [u8]) -> Builder<'_> {
         Builder { bytes, pos: 0 }
     }
 
+    #[inline]
     pub fn with_pos(bytes: &mut [u8], pos: usize) -> Builder<'_> {
         Builder { bytes, pos }
     }
 
     /// The string's length, in bytes.
+    #[inline]
     pub fn len(&self) -> usize {
         self.bytes.len()
     }
 
+    #[inline]
     pub fn is_empty(&self) -> bool {
         self.len() == 0
     }
 
+    #[inline]
     pub fn as_bytes(self) -> &'a [u8] {
         self.bytes
     }
 
     /// Converts to a `str`, returning a error if the data contains invalid utf-8.
+    #[inline]
     pub fn to_str(self) -> core::result::Result<&'a str, core::str::Utf8Error> {
         str::from_utf8(self.bytes)
     }
 
     #[cfg(feature = "alloc")]
     /// Converts to a `String`, returning a error if the data contains invalid utf-8.
+    #[inline]
     pub fn to_string(self) -> core::result::Result<alloc::string::String, core::str::Utf8Error> {
         Ok(self.to_str()?.into())
     }
 
+    #[inline]
     pub fn as_bytes_mut(self) -> &'a mut [u8] {
         &mut self.bytes[..]
     }
 
     /// Writes a single ascii character at position `pos` and increments `pos`.
+    #[inline]
     pub fn push_ascii(&mut self, ascii: u8) {
         assert!(ascii < 128);
         self.bytes[self.pos] = ascii;
         self.pos += 1;
     }
 
     /// Writes a string at position `pos` and increases `pos` a corresponding amount.
+    #[inline]
     pub fn push_str(&mut self, string: &str) {
         let bytes = string.as_bytes();
         self.bytes[self.pos..(self.pos + bytes.len())].copy_from_slice(bytes);
@@ -214,17 +231,20 @@ impl<'a> Builder<'a> {
         self.pos = 0;
     }
 
+    #[inline]
     pub fn reborrow(&mut self) -> Builder<'_> {
         Builder {
             bytes: self.bytes,
             pos: self.pos,
         }
     }
 
+    #[inline]
     pub fn into_reader(self) -> Reader<'a> {
         Reader(self.bytes)
     }
 
+    #[inline]
     pub fn reborrow_as_reader(&self) -> Reader<'_> {
         Reader(self.bytes)
     }