Merge pull request #1331 from WonderLawrence/rawvalue-from-string-unchecked

Add RawValue::from_string_unchecked

Author: dtolnay

src/raw.rs

@@ -191,6 +191,49 @@ 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.
+    ///
+    /// In debug builds this contract is checked with a `debug_assert!` that
+    /// re-parses the input; the check is compiled out in release builds, so
+    /// only release performance matches the "no re-parse" guarantee above.
+    ///
+    /// # 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> {
+        debug_assert!(
+            crate::from_str::<&Self>(&json).is_ok_and(|v| v.json.len() == json.len()),
+            "from_string_unchecked: input is not a single well-formed JSON value \
+             with no leading or trailing whitespace",
+        );
+        Self::from_owned(json.into_boxed_str())
+    }
+
     /// Access the JSON text underlying a raw value.
     ///
     /// # Example

tests/test.rs

@@ -2455,6 +2455,56 @@ 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());
+}
+
+// The debug_assert! inside from_string_unchecked is compiled out of release
+// builds, so #[should_panic] can only be exercised under debug (which is the
+// default `cargo test` profile).
+#[cfg(all(feature = "raw_value", debug_assertions))]
+#[test]
+#[should_panic = "from_string_unchecked"]
+fn test_raw_value_from_string_unchecked_debug_asserts_whitespace() {
+    let _ = unsafe { RawValue::from_string_unchecked(" 42".to_owned()) };
+}
+
+#[cfg(all(feature = "raw_value", debug_assertions))]
+#[test]
+#[should_panic = "from_string_unchecked"]
+fn test_raw_value_from_string_unchecked_debug_asserts_well_formed() {
+    let _ = unsafe { RawValue::from_string_unchecked("[1,".to_owned()) };
+}
+
 #[cfg(feature = "raw_value")]
 #[test]
 fn test_raw_invalid_utf8() {