Add RawValue::from_string_unchecked

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: WonderLawrence

src/raw.rs

@@ -191,6 +191,40 @@ impl RawValue {
         Ok(Self::from_owned(json.into_boxed_str()))
     }
 
+    /// Convert an owned `String` of JSON data to an owned `RawValue` without
+    /// checking that it contains valid JSON.
+    ///
+    /// This is the unchecked counterpart of [`RawValue::from_string`], for
+    /// strings that are already known to be valid JSON, such as the output of
+    /// another JSON serializer. Unlike `from_string`, it does not re-parse the
+    /// string; the only cost is `String::into_boxed_str`.
+    ///
+    /// # Safety
+    ///
+    /// The string passed in must contain a single well-formed JSON value with
+    /// no leading or trailing whitespace. `RawValue` is written verbatim into
+    /// JSON output wherever it is embedded, and other code (including unsafe
+    /// code) is allowed to rely on `RawValue` upholding this invariant, in the
+    /// same way that unsafe code may rely on `str` containing valid UTF-8.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use serde_json::value::RawValue;
+    ///
+    /// let json = serde_json::to_string(&[1, 2, 3])?;
+    ///
+    /// // SAFETY: `json` was produced by serde_json's own serializer, so it is
+    /// // a single well-formed JSON value without surrounding whitespace.
+    /// let raw = unsafe { RawValue::from_string_unchecked(json) };
+    ///
+    /// assert_eq!(raw.get(), "[1,2,3]");
+    /// # Ok::<(), serde_json::Error>(())
+    /// ```
+    pub unsafe fn from_string_unchecked(json: String) -> Box<Self> {
+        Self::from_owned(json.into_boxed_str())
+    }
+
     /// Access the JSON text underlying a raw value.
     ///
     /// # Example

tests/test.rs

@@ -2455,6 +2455,39 @@ fn test_boxed_raw_value() {
     assert_eq!(r#"["a",42,{"foo": "bar"},null]"#, array_to_string);
 }
 
+#[cfg(feature = "raw_value")]
+#[test]
+fn test_raw_value_from_string_unchecked() {
+    #[derive(Serialize)]
+    struct Wrapper {
+        a: i8,
+        b: Box<RawValue>,
+        c: i8,
+    }
+
+    let json = r#"{"foo":[1,2,3],"bar":"\"escaped\""}"#.to_owned();
+    let checked = RawValue::from_string(json.clone()).unwrap();
+    let unchecked = unsafe { RawValue::from_string_unchecked(json) };
+    assert_eq!(checked.get(), unchecked.get());
+
+    let wrapper = Wrapper {
+        a: 1,
+        b: unchecked,
+        c: 3,
+    };
+    let wrapper_to_string = serde_json::to_string(&wrapper).unwrap();
+    assert_eq!(
+        r#"{"a":1,"b":{"foo":[1,2,3],"bar":"\"escaped\""},"c":3}"#,
+        wrapper_to_string,
+    );
+
+    // A string with excess capacity is preserved as-is.
+    let mut spare = String::with_capacity(64);
+    spare.push_str("[1,2,3]");
+    let raw = unsafe { RawValue::from_string_unchecked(spare) };
+    assert_eq!("[1,2,3]", raw.get());
+}
+
 #[cfg(feature = "raw_value")]
 #[test]
 fn test_raw_invalid_utf8() {