rubydex 0.4.3 → 0.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 427fb322be8d5ed974dbd0ea8a1c70b90457b95955d3ef5de1e0bba54b48ec16
-  data.tar.gz: 5dcf6a17e96ec38f2de7351b36b0d6e04c1e558645487c3cb38c5d00be6be003
+  metadata.gz: 196878527af0452d4afb518e0520ed26ccf7370fc6755954d70038afa6e0f66e
+  data.tar.gz: 864a4ac367601c64a465946115b732da341971b2a7c9d06f96ce8b3fae983354
 SHA512:
-  metadata.gz: 7c7d78c466ac7e1b5312ac5e8bc74dfc55ac111b7f53eb119251def4f11d32d24051cdff1ebe15cc67d7557f6a9de7051ac98bab7f174d9bb07f76d210bc8abc
-  data.tar.gz: 2bb52d1af8cecc3e57905fe10173d5758d4b91c47ccdb48253780ba3e422fee57a5d73072351a344288bb4c2761d13c95ba279ce91e31da6dd9997f3f472cdc2
+  metadata.gz: 30ef223c97026abc1cb3f1a8c84048f87889dbb96aa01fc81fe37a9db52109cbb774ba492635ec09067050ab7a33dbd2b7f40aac5512dc81367d7f0009c036ee
+  data.tar.gz: 20e4b61e4790603a8589419404d85011ef0f9342b4e0cc65f056b19fdadc5a6d881a37f3e49cd9328c072bc64cc6e988350e0372da32243632d5ae2a1de2fcbf

data/THIRD_PARTY_LICENSES.html

@@ -2848,10 +2848,10 @@ SOFTWARE.
                 <ul class="license-used-by">
                     <li><a
                             href=" https://github.com/Shopify/rubydex ">rubydex
-                            0.4.3</a></li>
+                            0.4.4</a></li>
                     <li><a
                             href=" https://github.com/Shopify/rubydex ">rubydex-sys
-                            0.4.3</a></li>
+                            0.4.4</a></li>
                     <li><a
                             href=" https://github.com/DimaKudosh/difflib ">difflib
                             0.4.0</a></li>

data/ext/rubydex/declaration.c

@@ -60,9 +60,7 @@ VALUE rdxi_declaration_class_for_kind(CDeclarationKind kind) {
 static VALUE rdxr_declaration_name(VALUE self) {
     HandleData *data;
     void *graph = rdxi_graph_from_handle(self, &data);
-    const char *name = rdx_declaration_name(graph, data->id);
-
-    return rdxi_owned_c_string_to_ruby(name);
+    return rdxi_owned_string_to_ruby(rdx_declaration_name(graph, data->id));
 }
 
 /*
@@ -74,9 +72,7 @@ static VALUE rdxr_declaration_name(VALUE self) {
 static VALUE rdxr_declaration_unqualified_name(VALUE self) {
     HandleData *data;
     void *graph = rdxi_graph_from_handle(self, &data);
-    const char *name = rdx_declaration_unqualified_name(graph, data->id);
-
-    return rdxi_owned_c_string_to_ruby(name);
+    return rdxi_owned_string_to_ruby(rdx_declaration_unqualified_name(graph, data->id));
 }
 
 // Body function for rb_ensure in Declaration#definitions

data/ext/rubydex/definition.c

@@ -132,7 +132,7 @@ static VALUE rdxr_definition_comments(VALUE self) {
     for (size_t i = 0; i < arr->len; i++) {
         CommentEntry entry = arr->items[i];
 
-        VALUE string = rb_utf8_str_new_cstr(entry.string);
+        VALUE string = rb_utf8_str_new(entry.string.data, (long)entry.string.length);
 
         Location *loc = entry.location;
         VALUE location = rdxi_build_location_value(loc);
@@ -160,8 +160,7 @@ static VALUE rdxr_definition_name(VALUE self) {
     HandleData *data;
     void *graph = rdxi_graph_from_handle(self, &data);
 
-    const char *name = rdx_definition_name(graph, data->id);
-    return rdxi_owned_c_string_to_ruby(name);
+    return rdxi_owned_string_to_ruby(rdx_definition_name(graph, data->id));
 }
 
 /*

data/ext/rubydex/graph.c

@@ -679,7 +679,8 @@ static VALUE rdxr_graph_diagnostics(VALUE self) {
     VALUE diagnostics = rb_ary_new_capa((long)array->len);
     for (size_t i = 0; i < array->len; i++) {
         DiagnosticEntry entry = array->items[i];
-        VALUE message = entry.message == NULL ? Qnil : rb_utf8_str_new_cstr(entry.message);
+        VALUE message =
+            entry.message.data == NULL ? Qnil : rb_utf8_str_new(entry.message.data, (long)entry.message.length);
         VALUE rule = rdxi_rule_class_from_name(entry.rule.name, entry.rule.name_length);
         VALUE location = rdxi_build_location_value(entry.location);
 

data/ext/rubydex/query.c

@@ -188,7 +188,9 @@ static VALUE cypher_cell_to_value(VALUE graph_obj, const struct CCell *cell) {
     case CCellTag_Int:
         return LL2NUM(cell->payload.int_val);
     case CCellTag_Str:
-        return cell->payload.str_val == NULL ? Qnil : rb_utf8_str_new_cstr(cell->payload.str_val);
+        return cell->payload.str_val.data == NULL
+                   ? Qnil
+                   : rb_utf8_str_new(cell->payload.str_val.data, (long)cell->payload.str_val.length);
     case CCellTag_List: {
         VALUE array = rb_ary_new_capa((long)cell->payload.list.len);
         for (size_t i = 0; i < cell->payload.list.len; i++) {

data/ext/rubydex/reference.c

@@ -86,11 +86,11 @@ static VALUE rdxr_method_reference_name(VALUE self) {
     HandleData *data;
     void *graph = rdxi_graph_from_handle(self, &data);
 
-    const char *name = rdx_method_reference_name(graph, data->id);
-    if (name == NULL) {
+    OwnedString name = rdx_method_reference_name(graph, data->id);
+    if (name.data == NULL) {
         rb_raise(rb_eRuntimeError, "Method reference must exist for a valid id");
     }
-    return rdxi_owned_c_string_to_ruby(name);
+    return rdxi_owned_string_to_ruby(name);
 }
 
 /*

data/ext/rubydex/utils.c

@@ -59,6 +59,19 @@ VALUE rdxi_owned_c_string_to_ruby(const char *string) {
     return value;
 }
 
+// Convert a Rust-owned string with an explicit length to a Ruby string and release it with free_owned_string.
+// Returns nil when the Rust side returned a null string.
+VALUE rdxi_owned_string_to_ruby(OwnedString string) {
+    if (string.data == NULL) {
+        return Qnil;
+    }
+
+    VALUE value = rb_utf8_str_new(string.data, (long)string.length);
+    free_owned_string(string);
+
+    return value;
+}
+
 // Coerce an optional String, Symbol, or nil to a C string, defaulting to `default_value` for nil.
 const char *rdxi_symbol_or_string_cstr(VALUE value, const char *default_value) {
     if (NIL_P(value)) {

data/ext/rubydex/utils.h

@@ -2,6 +2,7 @@
 #define RUBYDEX_UTILS_H
 
 #include "ruby.h"
+#include "rustbindings.h"
 
 // Convert a Ruby array of strings into a double char pointer so that we can pass that to Rust.
 // This copies the data so it must be freed with rdxi_free_str_array
@@ -17,6 +18,10 @@ void rdxi_check_array_of_strings(VALUE array);
 // Returns nil when the Rust side returned NULL.
 VALUE rdxi_owned_c_string_to_ruby(const char *string);
 
+// Convert a Rust-owned string with an explicit length to a Ruby string and release it with free_owned_string. Unlike
+// a C string, it may contain NUL bytes. Returns nil when the Rust side returned a null string.
+VALUE rdxi_owned_string_to_ruby(OwnedString string);
+
 // Coerce an optional String, Symbol, or nil to a C string, returning `default_value` when the value
 // is nil. A non-nil value must be a String or Symbol, otherwise a `TypeError` is raised. The
 // returned pointer is owned by the Ruby VALUE and is only valid while it stays live.

data/lib/rubydex/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rubydex
-  VERSION = "0.4.3"
+  VERSION = "0.4.4"
 end

data/rust/Cargo.lock

@@ -760,7 +760,7 @@ dependencies = [
 
 [[package]]
 name = "rubydex"
-version = "0.4.3"
+version = "0.4.4"
 dependencies = [
  "assert_cmd",
  "bitflags",
@@ -789,7 +789,7 @@ dependencies = [
 
 [[package]]
 name = "rubydex-sys"
-version = "0.4.3"
+version = "0.4.4"
 dependencies = [
  "cbindgen",
  "libc",

data/rust/Cargo.toml

@@ -7,7 +7,8 @@ members = [
 resolver = "3"
 
 [workspace.package]
-version = "0.4.3"
+version = "0.4.4"
+rust-version = "1.99.1"
 
 [profile.release]
 lto = true
@@ -28,4 +29,4 @@ complexity = "deny"
 style = "deny"
 pedantic = "warn"
 
-ptr-as-ptr = { level = "deny", priority = 1 }
+ptr_as_ptr = { level = "deny", priority = 1 }

data/rust/rubydex/Cargo.toml

@@ -2,7 +2,7 @@
 name = "rubydex"
 version.workspace = true
 edition = "2024"
-rust-version = "1.89.0"
+rust-version.workspace = true
 license = "MIT"
 description = "High-performance Ruby code indexing and static analysis library."
 homepage = "https://github.com/Shopify/rubydex"

data/rust/rubydex-sys/Cargo.toml

@@ -2,7 +2,7 @@
 name = "rubydex-sys"
 version.workspace = true
 edition = "2024"
-rust-version = "1.89.0"
+rust-version.workspace = true
 license = "MIT"
 description = "C FFI bindings for the Rubydex Ruby code indexing engine."
 homepage = "https://github.com/Shopify/rubydex"
@@ -15,7 +15,7 @@ categories = ["development-tools", "external-ffi-bindings"]
 crate-type = ["cdylib", "staticlib"]
 
 [dependencies]
-rubydex = { version = "=0.4.3", path = "../rubydex" }
+rubydex = { version = "=0.4.4", path = "../rubydex" }
 libc = "0.2.174"
 url = "2.5.4"
 line-index = "0.1.2"

data/rust/rubydex-sys/src/cypher_api.rs

@@ -5,11 +5,13 @@ use crate::declaration_api::CDeclaration;
 use crate::definition_api::map_definition_to_kind;
 use crate::graph_api::{GraphPointer, with_graph};
 use crate::utils;
+use crate::utils::OwnedString;
 use libc::{c_char, c_void};
 use rubydex::model::graph::Graph;
 use rubydex::query::cypher::schema::NodeRef;
 use rubydex::query::cypher::{self, CypherValue, OutputFormat};
 use std::ffi::CString;
+use std::mem::ManuallyDrop;
 use std::ptr;
 
 /// Which layer of the Cypher pipeline rejected a call, so callers can raise a matching error class.
@@ -201,14 +203,13 @@ pub struct CMap {
 /// Payload of a `CCell`. The active field is selected by the cell's `tag`; reading any other field
 /// is undefined. `Null` carries no payload.
 #[repr(C)]
-#[derive(Clone, Copy)]
 pub union CCellPayload {
     /// `Bool`.
     pub bool_val: bool,
     /// `Int`.
     pub int_val: i64,
-    /// `Str`: owned C string (freed by `rdx_rows_iter_free`).
-    pub str_val: *const c_char,
+    /// `Str`: owned string (freed by `rdx_rows_iter_free`). A union never drops its fields, so `free_cell` drops it.
+    pub str_val: ManuallyDrop<OwnedString>,
     /// `Node`.
     pub node: CNode,
     /// `List`.
@@ -306,7 +307,7 @@ fn build_cell(graph: &Graph, value: &CypherValue) -> Result<CCell, String> {
         CypherValue::Str(s) => Ok(CCell::new(
             CCellTag::Str,
             CCellPayload {
-                str_val: utils::cstring_raw(s),
+                str_val: ManuallyDrop::new(OwnedString::new(s)),
             },
         )),
         CypherValue::List(items) => {
@@ -715,10 +716,9 @@ unsafe fn free_cell(cell: &CCell) {
     match cell.tag {
         // SAFETY: the tag selects the active union field.
         CCellTag::Str => {
-            let str_val = unsafe { cell.payload.str_val };
-            if !str_val.is_null() {
-                let _ = unsafe { CString::from_raw(str_val.cast_mut()) };
-            }
+            // The cell is not used after this, so moving the string out of it is sound
+            let string = unsafe { ptr::read(&raw const cell.payload.str_val) };
+            drop(ManuallyDrop::into_inner(string));
         }
         // SAFETY: the tag selects the active union field.
         CCellTag::List => {

data/rust/rubydex-sys/src/declaration_api.rs

@@ -2,13 +2,13 @@
 
 use libc::c_char;
 use rubydex::model::declaration::{Ancestor, Declaration, Namespace};
-use std::ffi::CString;
 use std::ptr;
 
 use crate::definition_api::{DefinitionsIter, rdx_definitions_iter_new_from_ids};
 use crate::graph_api::{GraphPointer, with_graph};
 use crate::reference_api::{CConstantReference, CMethodReference, ConstantReferencesIter, MethodReferencesIter};
 use crate::utils;
+use crate::utils::OwnedString;
 use rubydex::model::ids::{DeclarationId, StringId, declaration_id_from_lookup_name};
 
 #[repr(C)]
@@ -119,24 +119,20 @@ pub unsafe extern "C" fn rdx_graph_declarations_iter_free(iter: *mut Declaration
     unsafe { DeclarationsIter::free(iter) }
 }
 
-/// Returns the UTF-8 name string for a declaration id.
-/// Caller must free with `free_c_string`.
+/// Returns the UTF-8 name string for a declaration id, or a null string if the declaration cannot be found.
+/// Caller must free with `free_owned_string`.
 ///
 /// # Safety
 ///
 /// Assumes pointer is valid.
-///
-/// # Panics
-///
-/// This function will panic if the name pointer is invalid.
 #[unsafe(no_mangle)]
-pub unsafe extern "C" fn rdx_declaration_name(pointer: GraphPointer, name_id: u64) -> *const c_char {
+pub unsafe extern "C" fn rdx_declaration_name(pointer: GraphPointer, name_id: u64) -> OwnedString {
     with_graph(pointer, |graph| {
         let name_id = DeclarationId::new(name_id);
         if let Some(decl) = graph.declarations().get(&name_id) {
-            CString::new(decl.name()).unwrap().into_raw().cast_const()
+            OwnedString::new(decl.name())
         } else {
-            ptr::null()
+            OwnedString::null()
         }
     })
 }
@@ -213,24 +209,20 @@ pub unsafe extern "C" fn rdx_declaration_find_member(
     })
 }
 
-/// Returns the UTF-8 unqualified name string for a declaration id.
-/// Caller must free with `free_c_string`.
+/// Returns the UTF-8 unqualified name string for a declaration id, or a null string if the declaration cannot be
+/// found. Caller must free with `free_owned_string`.
 ///
 /// # Safety
 ///
 /// Assumes pointer is valid.
-///
-/// # Panics
-///
-/// This function will panic if the name pointer is invalid.
 #[unsafe(no_mangle)]
-pub unsafe extern "C" fn rdx_declaration_unqualified_name(pointer: GraphPointer, name_id: u64) -> *const c_char {
+pub unsafe extern "C" fn rdx_declaration_unqualified_name(pointer: GraphPointer, name_id: u64) -> OwnedString {
     with_graph(pointer, |graph| {
         let name_id = DeclarationId::new(name_id);
         if let Some(decl) = graph.declarations().get(&name_id) {
-            CString::new(decl.unqualified_name()).unwrap().into_raw().cast_const()
+            OwnedString::new(&decl.unqualified_name())
         } else {
-            ptr::null()
+            OwnedString::null()
         }
     })
 }

data/rust/rubydex-sys/src/definition_api.rs

@@ -4,6 +4,7 @@ use crate::declaration_api::CDeclaration;
 use crate::graph_api::{GraphPointer, with_graph};
 use crate::location_api::{Location, create_location_for_uri_and_offset};
 use crate::reference_api::CConstantReference;
+use crate::utils::OwnedString;
 use libc::c_char;
 use rubydex::model::definitions::{Definition, Mixin};
 use rubydex::model::graph::Graph;
@@ -84,30 +85,26 @@ pub unsafe extern "C" fn rdx_definition_kind(pointer: GraphPointer, definition_i
     })
 }
 
-/// Returns the UTF-8 unqualified name string for a definition id.
-/// Caller must free with `free_c_string`.
+/// Returns the UTF-8 unqualified name string for a definition id, or a null string if the definition cannot be found.
+/// Caller must free with `free_owned_string`.
 ///
 /// # Safety
 ///
 /// Assumes pointer is valid.
-///
-/// # Panics
-///
-/// This function will panic if the definition cannot be found.
 #[unsafe(no_mangle)]
-pub unsafe extern "C" fn rdx_definition_name(pointer: GraphPointer, definition_id: u64) -> *const c_char {
+pub unsafe extern "C" fn rdx_definition_name(pointer: GraphPointer, definition_id: u64) -> OwnedString {
     with_graph(pointer, |graph| {
         let def_id = DefinitionId::new(definition_id);
         if let Some(defn) = graph.definitions().get(&def_id) {
             let string_id = graph.definition_string_id(defn);
 
             if let Some(name) = graph.strings().get(&string_id) {
-                CString::new(name.as_str()).unwrap().into_raw().cast_const()
+                OwnedString::new(name.as_str())
             } else {
-                ptr::null()
+                OwnedString::null()
             }
         } else {
-            ptr::null()
+            OwnedString::null()
         }
     })
 }
@@ -212,7 +209,7 @@ pub unsafe extern "C" fn rdx_definitions_iter_free(iter: *mut DefinitionsIter) {
 /// C-compatible struct representing a single comment with its string and location
 #[repr(C)]
 pub struct CommentEntry {
-    pub string: *const c_char,
+    pub string: OwnedString,
     pub location: *mut Location,
 }
 
@@ -248,7 +245,7 @@ pub unsafe extern "C" fn rdx_definition_comments(pointer: GraphPointer, definiti
             .comments()
             .iter()
             .map(|c| CommentEntry {
-                string: CString::new(c.string()).unwrap().into_raw().cast_const(),
+                string: OwnedString::new(c.string()),
                 location: create_location_for_uri_and_offset(graph, document, c.offset()),
             })
             .collect::<Vec<CommentEntry>>()
@@ -282,17 +279,13 @@ pub unsafe extern "C" fn rdx_definition_comments_free(ptr: *mut CommentArray) {
         let mut boxed_slice: Box<[CommentEntry]> = unsafe { Box::from_raw(slice_ptr) };
 
         for item in &mut boxed_slice {
-            if !item.string.is_null() {
-                // Free the CString allocated for the comment string
-                let _ = unsafe { CString::from_raw(item.string.cast_mut()) };
-            }
             if !item.location.is_null() {
                 unsafe { crate::location_api::rdx_location_free(item.location) };
                 item.location = ptr::null_mut();
             }
         }
 
-        // boxed_slice is dropped here, freeing the items buffer
+        // boxed_slice is dropped here, freeing the items buffer and each item's string
     }
     // arr is dropped here
 }

data/rust/rubydex-sys/src/diagnostic_api.rs

@@ -2,9 +2,10 @@
 
 use crate::graph_api::{GraphPointer, with_graph};
 use crate::location_api::{Location, create_location_for_uri_and_offset};
+use crate::utils::OwnedString;
 use libc::c_char;
 use rubydex::diagnostic::{Rule, Severity};
-use std::{ffi::CString, mem, ptr};
+use std::{mem, ptr};
 
 /// C-compatible enum representing diagnostic severity levels.
 #[repr(C)]
@@ -49,7 +50,7 @@ impl From<Rule> for CRule {
 #[repr(C)]
 pub struct DiagnosticEntry {
     pub rule: CRule,
-    pub message: *const c_char,
+    pub message: OwnedString,
     pub location: *mut Location,
 }
 
@@ -91,7 +92,7 @@ pub unsafe extern "C" fn rdx_graph_diagnostics(pointer: GraphPointer) -> *mut Di
 
                 DiagnosticEntry {
                     rule: CRule::from(*diagnostic.rule()),
-                    message: CString::new(diagnostic.message()).unwrap().into_raw().cast_const(),
+                    message: OwnedString::new(diagnostic.message()),
                     location,
                 }
             })
@@ -119,15 +120,12 @@ pub unsafe extern "C" fn rdx_diagnostics_free(ptr: *mut DiagnosticArray) {
         let mut boxed_slice: Box<[DiagnosticEntry]> = unsafe { Box::from_raw(slice_ptr) };
 
         for entry in &mut *boxed_slice {
-            if !entry.message.is_null() {
-                let _ = unsafe { CString::from_raw(entry.message.cast_mut()) };
-            }
             if !entry.location.is_null() {
                 unsafe { crate::location_api::rdx_location_free(entry.location) };
                 entry.location = ptr::null_mut();
             }
         }
-        // boxed_slice drops here, releasing the buffer
+        // boxed_slice drops here, releasing the buffer and each entry's message
     }
     // array drops here
 }

data/rust/rubydex-sys/src/reference_api.rs

@@ -6,6 +6,7 @@ use std::ptr;
 use crate::declaration_api::CDeclaration;
 use crate::graph_api::{GraphPointer, with_graph};
 use crate::location_api::{Location, create_location_for_uri_and_offset};
+use crate::utils::OwnedString;
 use libc::c_char;
 use rubydex::model::graph::Graph;
 use rubydex::model::ids::{ConstantReferenceId, MethodReferenceId};
@@ -148,8 +149,8 @@ pub unsafe extern "C" fn rdx_constant_reference_name(pointer: GraphPointer, refe
     })
 }
 
-/// Returns the UTF-8 name string for a method reference id, or NULL if the reference cannot be found.
-/// Caller must free with `free_c_string`.
+/// Returns the UTF-8 name string for a method reference id, or a null string if the reference cannot be found.
+/// Caller must free with `free_owned_string`.
 ///
 /// # Safety
 ///
@@ -159,18 +160,14 @@ pub unsafe extern "C" fn rdx_constant_reference_name(pointer: GraphPointer, refe
 ///
 /// This function will panic if the reference's name cannot be found.
 #[unsafe(no_mangle)]
-pub unsafe extern "C" fn rdx_method_reference_name(pointer: GraphPointer, reference_id: u64) -> *const c_char {
+pub unsafe extern "C" fn rdx_method_reference_name(pointer: GraphPointer, reference_id: u64) -> OwnedString {
     with_graph(pointer, |graph| {
         let ref_id = MethodReferenceId::new(reference_id);
         let Some(reference) = graph.method_references().get(&ref_id) else {
-            return ptr::null();
+            return OwnedString::null();
         };
-        let name = graph
-            .strings()
-            .get(reference.str())
-            .expect("Name ID should exist")
-            .to_string();
-        CString::new(name).unwrap().into_raw().cast_const()
+        let name = graph.strings().get(reference.str()).expect("Name ID should exist");
+        OwnedString::new(name.as_str())
     })
 }
 

data/rust/rubydex-sys/src/utils.rs

@@ -1,6 +1,7 @@
 use libc::{c_char, size_t};
 use std::ffi::{CStr, CString};
 use std::path::Path;
+use std::ptr;
 use std::slice;
 use std::str::Utf8Error;
 
@@ -42,6 +43,54 @@ pub extern "C" fn free_c_string(ptr: *const c_char) {
     }
 }
 
+/// C-compatible owned UTF-8 string with an explicit length. Unlike a C string, it is not NUL-terminated and may
+/// contain NUL bytes, which source code can put into names, comments and diagnostic messages. A null `data` means
+/// there is no string. Dropping it frees the bytes
+#[repr(C)]
+pub struct OwnedString {
+    pub data: *const c_char,
+    pub length: usize,
+}
+
+impl OwnedString {
+    #[must_use]
+    pub fn new(value: &str) -> Self {
+        let bytes: Box<[u8]> = value.as_bytes().into();
+        Self {
+            length: bytes.len(),
+            data: Box::into_raw(bytes).cast::<c_char>().cast_const(),
+        }
+    }
+
+    #[must_use]
+    pub fn null() -> Self {
+        Self {
+            data: ptr::null(),
+            length: 0,
+        }
+    }
+}
+
+impl Drop for OwnedString {
+    fn drop(&mut self) {
+        if !self.data.is_null() {
+            let bytes = ptr::slice_from_raw_parts_mut(self.data.cast_mut().cast::<u8>(), self.length);
+            // SAFETY: a non-null `data` always comes from `Box::into_raw` in `OwnedString::new`, with `length` bytes
+            let _ = unsafe { Box::from_raw(bytes) };
+        }
+    }
+}
+
+/// Frees an `OwnedString` allocated on the Rust side
+///
+/// # Safety
+///
+/// - `string` must have been returned by a rubydex function and must not be used after being freed
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn free_owned_string(string: OwnedString) {
+    drop(string);
+}
+
 /// Frees a boxed u64 allocated on the Rust side
 #[unsafe(no_mangle)]
 pub extern "C" fn free_u64(ptr: *const u64) {

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubydex
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.4.4
 platform: ruby
 authors:
   - Shopify