Avoid into_owned() tree rebuild in Decode for Vec<u8>

Parameterize decode_impl with const generic BORROW to control whether
leaf values (Binary/Text) use Cow::Borrowed or Cow::Owned. When
BORROW=false, owned values are produced directly during parsing,
eliminating the post-decode into_owned() walk that was rebuilding
every BTreeMap and Vec container. This fixes the 10-20% decode_scalar
regression on small/medium files introduced by the Cow migration.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: moreal

src/codec/decode.rs

@@ -110,7 +110,9 @@ impl Expect<u8> for u8 {
     }
 }
 
-fn decode_impl<'a>(
+/// When `BORROW` is true, Binary/Text values borrow from the input slice (zero-copy).
+/// When `BORROW` is false, Binary/Text values are owned copies (for `Decode for Vec<u8>`).
+fn decode_impl<'a, const BORROW: bool>(
     vector: &'a [u8],
     start: usize,
 ) -> Result<(BencodexValue<'a>, usize), DecodeError> {
@@ -119,11 +121,11 @@ fn decode_impl<'a>(
     }
 
     match vector[start] {
-        b'd' => decode_dict_impl(vector, start),
-        b'l' => decode_list_impl(vector, start),
-        b'u' => decode_unicode_string_impl(vector, start),
+        b'd' => decode_dict_impl::<BORROW>(vector, start),
+        b'l' => decode_list_impl::<BORROW>(vector, start),
+        b'u' => decode_unicode_string_impl::<BORROW>(vector, start),
         b'i' => decode_number_impl(vector, start),
-        b'0'..=b'9' => decode_byte_string_impl(vector, start),
+        b'0'..=b'9' => decode_byte_string_impl::<BORROW>(vector, start),
         b't' => Ok((BencodexValue::Boolean(true), 1)),
         b'f' => Ok((BencodexValue::Boolean(false), 1)),
         b'n' => Ok((BencodexValue::Null, 1)),
@@ -134,8 +136,26 @@ fn decode_impl<'a>(
     }
 }
 
+#[inline(always)]
+fn cow_binary<'a, const BORROW: bool>(data: &'a [u8]) -> Cow<'a, [u8]> {
+    if BORROW {
+        Cow::Borrowed(data)
+    } else {
+        Cow::Owned(data.to_vec())
+    }
+}
+
+#[inline(always)]
+fn cow_text<'a, const BORROW: bool>(text: &'a str) -> Cow<'a, str> {
+    if BORROW {
+        Cow::Borrowed(text)
+    } else {
+        Cow::Owned(text.to_string())
+    }
+}
+
 // start must be on 'd'
-fn decode_dict_impl<'a>(
+fn decode_dict_impl<'a, const BORROW: bool>(
     vector: &'a [u8],
     start: usize,
 ) -> Result<(BencodexValue<'a>, usize), DecodeError> {
@@ -148,15 +168,15 @@ fn decode_dict_impl<'a>(
     let mut index = start + tsize;
     let mut map = BTreeMap::new();
     while vector.get(index).should_not_be_none()? != b'e' {
-        let (value, size) = decode_impl(vector, index)?;
+        let (value, size) = decode_impl::<BORROW>(vector, index)?;
         let key = match value {
             BencodexValue::Text(s) => BencodexKey::Text(s),
             BencodexValue::Binary(b) => BencodexKey::Binary(b),
             _ => return Err(DecodeError::InvalidBencodexValueError),
         };
         tsize += size;
         index = start + tsize;
-        let (value, size) = decode_impl(vector, index)?;
+        let (value, size) = decode_impl::<BORROW>(vector, index)?;
 
         match map.insert(key, value) {
             None => (),
@@ -176,7 +196,7 @@ fn decode_dict_impl<'a>(
 }
 
 // start must be on 'l'
-fn decode_list_impl<'a>(
+fn decode_list_impl<'a, const BORROW: bool>(
     vector: &'a [u8],
     start: usize,
 ) -> Result<(BencodexValue<'a>, usize), DecodeError> {
@@ -189,7 +209,7 @@ fn decode_list_impl<'a>(
     let mut list = Vec::new();
     let mut index = start + tsize;
     while vector.get(index).should_not_be_none()? != b'e' {
-        let (value, size) = decode_impl(vector, index)?;
+        let (value, size) = decode_impl::<BORROW>(vector, index)?;
         list.push(value);
         tsize += size;
         index = start + tsize
@@ -205,7 +225,7 @@ fn decode_list_impl<'a>(
     Ok((BencodexValue::List(list), tsize))
 }
 
-fn decode_byte_string_impl<'a>(
+fn decode_byte_string_impl<'a, const BORROW: bool>(
     vector: &'a [u8],
     start: usize,
 ) -> Result<(BencodexValue<'a>, usize), DecodeError> {
@@ -226,15 +246,15 @@ fn decode_byte_string_impl<'a>(
         return Err(DecodeError::InvalidBencodexValueError);
     }
     Ok((
-        BencodexValue::Binary(Cow::Borrowed(
+        BencodexValue::Binary(cow_binary::<BORROW>(
             &vector[start + tsize..start + tsize + length],
         )),
         tsize + length,
     ))
 }
 
 // start must be on 'u'
-fn decode_unicode_string_impl<'a>(
+fn decode_unicode_string_impl<'a, const BORROW: bool>(
     vector: &'a [u8],
     start: usize,
 ) -> Result<(BencodexValue<'a>, usize), DecodeError> {
@@ -273,7 +293,7 @@ fn decode_unicode_string_impl<'a>(
         Err(_) => return Err(DecodeError::InvalidBencodexValueError),
     };
     tsize += length;
-    Ok((BencodexValue::Text(Cow::Borrowed(text)), tsize))
+    Ok((BencodexValue::Text(cow_text::<BORROW>(text)), tsize))
 }
 
 // start must be on 'i'
@@ -386,7 +406,7 @@ fn read_number(s: &[u8]) -> Option<(BigInt, usize)> {
 /// assert_eq!(value, BencodexValue::Text("hello".into()));
 /// ```
 pub fn decode_borrowed(input: &[u8]) -> Result<BencodexValue<'_>, DecodeError> {
-    Ok(decode_impl(input, 0)?.0)
+    Ok(decode_impl::<true>(input, 0)?.0)
 }
 
 impl Decode for Vec<u8> {
@@ -400,7 +420,11 @@ impl Decode for Vec<u8> {
     /// assert_eq!(dictionary, BencodexValue::Dictionary(BTreeMap::new()));
     /// ```
     fn decode(self) -> Result<BencodexValue<'static>, DecodeError> {
-        Ok(decode_impl(&self, 0)?.0.into_owned())
+        let value = decode_impl::<false>(&self, 0)?.0;
+        // SAFETY: With BORROW=false, all Cow values in the tree are Cow::Owned,
+        // so no references with the local lifetime exist. The lifetime parameter
+        // is purely phantom, making the transmute to 'static sound.
+        Ok(unsafe { core::mem::transmute::<BencodexValue<'_>, BencodexValue<'static>>(value) })
     }
 
     #[cfg(feature = "simd")]
@@ -417,9 +441,9 @@ mod tests {
         #[test]
         fn should_return_error_with_overflowed_start() {
             let expected_error = DecodeError::InvalidBencodexValueError;
-            assert_eq!(expected_error, decode_impl(&[], 1).unwrap_err());
-            assert_eq!(expected_error, decode_impl(b"12", 2).unwrap_err());
-            assert_eq!(expected_error, decode_impl(b"12", 20).unwrap_err());
+            assert_eq!(expected_error, decode_impl::<true>(&[], 1).unwrap_err());
+            assert_eq!(expected_error, decode_impl::<true>(b"12", 2).unwrap_err());
+            assert_eq!(expected_error, decode_impl::<true>(b"12", 20).unwrap_err());
         }
 
         #[test]
@@ -429,14 +453,14 @@ mod tests {
                     token: b'x',
                     point: 0,
                 },
-                decode_impl(b"x", 0).unwrap_err()
+                decode_impl::<true>(b"x", 0).unwrap_err()
             );
             assert_eq!(
                 DecodeError::UnexpectedTokenError {
                     token: b'k',
                     point: 4,
                 },
-                decode_impl(b"xyzok", 4).unwrap_err()
+                decode_impl::<true>(b"xyzok", 4).unwrap_err()
             );
         }
     }
@@ -447,24 +471,48 @@ mod tests {
         #[test]
         fn should_return_error_with_insufficient_length_source() {
             let expected_error = DecodeError::InvalidBencodexValueError;
-            assert_eq!(expected_error, decode_dict_impl(b"d", 0).unwrap_err());
-            assert_eq!(expected_error, decode_dict_impl(b"d", 2).unwrap_err());
-            assert_eq!(expected_error, decode_dict_impl(&[], 0).unwrap_err());
+            assert_eq!(
+                expected_error,
+                decode_dict_impl::<true>(b"d", 0).unwrap_err()
+            );
+            assert_eq!(
+                expected_error,
+                decode_dict_impl::<true>(b"d", 2).unwrap_err()
+            );
+            assert_eq!(
+                expected_error,
+                decode_dict_impl::<true>(&[], 0).unwrap_err()
+            );
         }
 
         #[test]
         fn should_return_error_with_source_having_incorrect_key() {
             let expected_error = DecodeError::InvalidBencodexValueError;
             // { 0: null }
-            assert_eq!(expected_error, decode_dict_impl(b"di0ene", 0).unwrap_err());
+            assert_eq!(
+                expected_error,
+                decode_dict_impl::<true>(b"di0ene", 0).unwrap_err()
+            );
             // { null: null }
-            assert_eq!(expected_error, decode_dict_impl(b"dnne", 0).unwrap_err());
+            assert_eq!(
+                expected_error,
+                decode_dict_impl::<true>(b"dnne", 0).unwrap_err()
+            );
             // { list: null }
-            assert_eq!(expected_error, decode_dict_impl(b"dlene", 0).unwrap_err());
+            assert_eq!(
+                expected_error,
+                decode_dict_impl::<true>(b"dlene", 0).unwrap_err()
+            );
             // { dictionary: null }
-            assert_eq!(expected_error, decode_dict_impl(b"ddene", 0).unwrap_err());
+            assert_eq!(
+                expected_error,
+                decode_dict_impl::<true>(b"ddene", 0).unwrap_err()
+            );
             // { boolean: null }
-            assert_eq!(expected_error, decode_dict_impl(b"dtene", 0).unwrap_err());
+            assert_eq!(
+                expected_error,
+                decode_dict_impl::<true>(b"dtene", 0).unwrap_err()
+            );
         }
 
         #[test]
@@ -474,14 +522,14 @@ mod tests {
                     token: b'k',
                     point: 1,
                 },
-                decode_dict_impl(b"dkne", 0).unwrap_err()
+                decode_dict_impl::<true>(b"dkne", 0).unwrap_err()
             );
             assert_eq!(
                 DecodeError::UnexpectedTokenError {
                     token: b'k',
                     point: 4,
                 },
-                decode_dict_impl(b"d1:ake", 0).unwrap_err()
+                decode_dict_impl::<true>(b"d1:ake", 0).unwrap_err()
             );
         }
     }
@@ -492,9 +540,18 @@ mod tests {
         #[test]
         fn should_return_error_with_insufficient_length_source() {
             let expected_error = DecodeError::InvalidBencodexValueError;
-            assert_eq!(expected_error, decode_list_impl(b"l", 0).unwrap_err());
-            assert_eq!(expected_error, decode_list_impl(b"l", 2).unwrap_err());
-            assert_eq!(expected_error, decode_list_impl(&[], 0).unwrap_err());
+            assert_eq!(
+                expected_error,
+                decode_list_impl::<true>(b"l", 0).unwrap_err()
+            );
+            assert_eq!(
+                expected_error,
+                decode_list_impl::<true>(b"l", 2).unwrap_err()
+            );
+            assert_eq!(
+                expected_error,
+                decode_list_impl::<true>(&[], 0).unwrap_err()
+            );
         }
 
         #[test]
@@ -504,7 +561,7 @@ mod tests {
                     token: b'k',
                     point: 1,
                 },
-                decode_list_impl(b"lke", 0).unwrap_err()
+                decode_list_impl::<true>(b"lke", 0).unwrap_err()
             );
         }
     }
@@ -517,17 +574,20 @@ mod tests {
             let expected_error = DecodeError::InvalidBencodexValueError;
             assert_eq!(
                 expected_error,
-                decode_byte_string_impl(b"1", 0).unwrap_err()
+                decode_byte_string_impl::<true>(b"1", 0).unwrap_err()
+            );
+            assert_eq!(
+                expected_error,
+                decode_byte_string_impl::<true>(b"1:", 0).unwrap_err()
             );
             assert_eq!(
                 expected_error,
-                decode_byte_string_impl(b"1:", 0).unwrap_err()
+                decode_byte_string_impl::<true>(b"2:a", 0).unwrap_err()
             );
             assert_eq!(
                 expected_error,
-                decode_byte_string_impl(b"2:a", 0).unwrap_err()
+                decode_byte_string_impl::<true>(&[], 0).unwrap_err()
             );
-            assert_eq!(expected_error, decode_byte_string_impl(&[], 0).unwrap_err());
         }
 
         #[test]
@@ -537,7 +597,7 @@ mod tests {
                     token: b'k',
                     point: 1,
                 },
-                decode_byte_string_impl(b"1ka", 0).unwrap_err()
+                decode_byte_string_impl::<true>(b"1ka", 0).unwrap_err()
             );
         }
     }
@@ -550,26 +610,26 @@ mod tests {
             let expected_error = DecodeError::InvalidBencodexValueError;
             assert_eq!(
                 expected_error,
-                decode_unicode_string_impl(b"u", 0).unwrap_err()
+                decode_unicode_string_impl::<true>(b"u", 0).unwrap_err()
             );
             assert_eq!(
                 expected_error,
-                decode_unicode_string_impl(b"u1", 0).unwrap_err()
+                decode_unicode_string_impl::<true>(b"u1", 0).unwrap_err()
             );
             assert_eq!(
                 expected_error,
-                decode_unicode_string_impl(b"u2:a", 0).unwrap_err()
+                decode_unicode_string_impl::<true>(b"u2:a", 0).unwrap_err()
             );
             assert_eq!(
                 DecodeError::UnexpectedTokenError {
                     token: b'k',
                     point: 1,
                 },
-                decode_unicode_string_impl(b"uk", 0).unwrap_err()
+                decode_unicode_string_impl::<true>(b"uk", 0).unwrap_err()
             );
             assert_eq!(
                 expected_error,
-                decode_unicode_string_impl(&[], 0).unwrap_err()
+                decode_unicode_string_impl::<true>(&[], 0).unwrap_err()
             );
         }
 
@@ -580,7 +640,7 @@ mod tests {
                     token: b'k',
                     point: 2
                 },
-                decode_unicode_string_impl(b"u1ka", 0).unwrap_err()
+                decode_unicode_string_impl::<true>(b"u1ka", 0).unwrap_err()
             );
         }
 
@@ -591,15 +651,15 @@ mod tests {
                     token: b'-',
                     point: 1,
                 },
-                decode_unicode_string_impl(b"u-1:a", 0).unwrap_err()
+                decode_unicode_string_impl::<true>(b"u-1:a", 0).unwrap_err()
             );
         }
 
         #[test]
         fn should_return_error_with_invalid_source_having_invalid_unicode_string() {
             assert_eq!(
                 DecodeError::InvalidBencodexValueError,
-                decode_unicode_string_impl(&[b'u', b'1', b':', 0x90], 0).unwrap_err()
+                decode_unicode_string_impl::<true>(&[b'u', b'1', b':', 0x90], 0).unwrap_err()
             );
         }
     }