In functions using ada_owned_string, return ada_owned_string instead of &str

src/ffi.rs

@@ -38,6 +38,19 @@ impl AsRef<str> for ada_owned_string {
     }
 }
 
+impl Drop for ada_owned_string {
+    fn drop(&mut self) {
+        // @note This is needed because ada_free_owned_string accepts by value
+        let copy = ada_owned_string {
+            data: self.data,
+            length: self.length,
+        };
+        unsafe {
+            ada_free_owned_string(copy);
+        };
+    }
+}
+
 #[repr(C)]
 pub struct ada_url_components {
     pub protocol_end: u32,

src/idna.rs

@@ -13,15 +13,11 @@ impl Idna {
     ///
     /// ```
     /// use ada_url::Idna;
-    /// assert_eq!(Idna::unicode("xn--meagefactory-m9a.ca"), "meßagefactory.ca");
+    /// assert_eq!(Idna::unicode("xn--meagefactory-m9a.ca").as_ref(), "meßagefactory.ca");
     /// ```
     #[must_use]
-    pub fn unicode(input: &str) -> &str {
-        unsafe {
-            let out = ffi::ada_idna_to_unicode(input.as_ptr().cast(), input.len());
-            let slice = core::slice::from_raw_parts(out.data.cast(), out.length);
-            core::str::from_utf8_unchecked(slice)
-        }
+    pub fn unicode(input: &str) -> ffi::ada_owned_string {
+        unsafe { ffi::ada_idna_to_unicode(input.as_ptr().cast(), input.len()) }
     }
 
     /// Process international domains according to the UTS #46 standard.
@@ -31,15 +27,11 @@ impl Idna {
     ///
     /// ```
     /// use ada_url::Idna;
-    /// assert_eq!(Idna::ascii("meßagefactory.ca"), "xn--meagefactory-m9a.ca");
+    /// assert_eq!(Idna::ascii("meßagefactory.ca").as_ref(), "xn--meagefactory-m9a.ca");
     /// ```
     #[must_use]
-    pub fn ascii(input: &str) -> &str {
-        unsafe {
-            let out = ffi::ada_idna_to_ascii(input.as_ptr().cast(), input.len());
-            let slice = core::slice::from_raw_parts(out.data.cast(), out.length);
-            core::str::from_utf8_unchecked(slice)
-        }
+    pub fn ascii(input: &str) -> ffi::ada_owned_string {
+        unsafe { ffi::ada_idna_to_ascii(input.as_ptr().cast(), input.len()) }
     }
 }
 
@@ -49,11 +41,17 @@ mod tests {
 
     #[test]
     fn unicode_should_work() {
-        assert_eq!(Idna::unicode("xn--meagefactory-m9a.ca"), "meßagefactory.ca");
+        assert_eq!(
+            Idna::unicode("xn--meagefactory-m9a.ca").as_ref(),
+            "meßagefactory.ca"
+        );
     }
 
     #[test]
     fn ascii_should_work() {
-        assert_eq!(Idna::ascii("meßagefactory.ca"), "xn--meagefactory-m9a.ca");
+        assert_eq!(
+            Idna::ascii("meßagefactory.ca").as_ref(),
+            "xn--meagefactory-m9a.ca"
+        );
     }
 }

src/lib.rs

@@ -267,15 +267,11 @@ impl Url {
     /// use ada_url::Url;
     ///
     /// let url = Url::parse("blob:https://example.com/foo", None).expect("Invalid URL");
-    /// assert_eq!(url.origin(), "https://example.com");
+    /// assert_eq!(url.origin().as_ref(), "https://example.com");
     /// ```
     #[must_use]
-    pub fn origin(&self) -> &str {
-        unsafe {
-            let out = ffi::ada_get_origin(self.0);
-            let slice = core::slice::from_raw_parts(out.data.cast(), out.length);
-            core::str::from_utf8_unchecked(slice)
-        }
+    pub fn origin(&self) -> ffi::ada_owned_string {
+        unsafe { ffi::ada_get_origin(self.0) }
     }
 
     /// Return the parsed version of the URL with all components.
@@ -949,7 +945,7 @@ mod test {
             None,
         )
         .expect("Should have parsed a simple url");
-        assert_eq!(out.origin(), "https://google.com:9090");
+        assert_eq!(out.origin().as_ref(), "https://google.com:9090");
         assert_eq!(
             out.href(),
             "https://username:[email protected]:9090/search?query#hash"