code_ownership 2.2.0 → 2.2.1

data/ext/cargo-vendor/{rb-sys-0.9.117 → rb-sys-0.9.130}/src/memory.rs

@@ -43,11 +43,22 @@
 #[macro_export]
 macro_rules! rb_gc_guard {
     ($v:expr) => {{
-        unsafe {
-            let val: $crate::VALUE = $v;
-            let rb_gc_guarded_ptr = std::ptr::read_volatile(&&val);
-            std::arch::asm!("/* {0} */", in(reg) rb_gc_guarded_ptr);
-            *rb_gc_guarded_ptr
-        }
+        // This matches Ruby's RB_GC_GUARD implementation:
+        //
+        //   volatile VALUE *rb_gc_guarded_ptr = &(v);
+        //   __asm__("" : : "m"(rb_gc_guarded_ptr));
+        //
+        // The empty asm with "m" (memory) constraint tells the compiler:
+        // 1. The value must be in memory (not just a register)
+        // 2. The compiler cannot reorder or eliminate this memory access
+        //
+        // In Rust, we achieve this by:
+        // 1. Taking a reference to force stack allocation
+        // 2. Using read_volatile to prevent optimization
+        let rb_gc_guarded_ptr: *const $crate::VALUE = &$v;
+        // SAFETY: rb_gc_guarded_ptr points to a valid, aligned VALUE on the
+        // stack (created on the line above). The read is volatile to ensure
+        // the compiler keeps the VALUE visible for conservative GC scanning.
+        unsafe { std::ptr::read_volatile(rb_gc_guarded_ptr) }
     }};
 }

data/ext/cargo-vendor/{rb-sys-0.9.117 → rb-sys-0.9.130}/src/stable_api/compiled.c

@@ -2,6 +2,7 @@
 #include "ruby/ruby.h"
 #include "ruby/intern.h"
 #include "ruby/version.h"
+#include "ruby/encoding.h"
 
 // Check that we have Ruby API version macros
 #if !defined(RUBY_API_VERSION_MAJOR)
@@ -41,6 +42,18 @@ impl_rarray_const_ptr(VALUE obj)
   return RARRAY_CONST_PTR(obj);
 }
 
+VALUE
+impl_rarray_aref(VALUE obj, long idx)
+{
+  return RARRAY_AREF(obj, idx);
+}
+
+void
+impl_rarray_aset(VALUE obj, long idx, VALUE val)
+{
+  RARRAY_ASET(obj, idx, val);
+}
+
 VALUE
 impl_rbasic_class(VALUE obj)
 {
@@ -152,16 +165,6 @@ int impl_rtypeddata_p(VALUE obj)
   return RTYPEDDATA_P(obj);
 }
 
-int impl_rtypeddata_embedded_p(VALUE obj)
-{
-#if RUBY_VERSION_AT_LEAST_3_3
-  return RTYPEDDATA_EMBEDDED_P(obj);
-#else
-  // On Ruby versions before 3.3, embedded typed data is not supported
-  return 0;
-#endif
-}
-
 const struct rb_data_type_struct *
 impl_rtypeddata_type(VALUE obj)
 {
@@ -177,3 +180,159 @@ impl_rtypeddata_get_data(VALUE obj)
   return RTYPEDDATA(obj)->data;
 #endif
 }
+
+VALUE
+impl_id2sym(ID id)
+{
+  return ID2SYM(id);
+}
+
+ID
+impl_sym2id(VALUE obj)
+{
+  return SYM2ID(obj);
+}
+
+long
+impl_fix2long(VALUE obj)
+{
+  return FIX2LONG(obj);
+}
+
+unsigned long
+impl_fix2ulong(VALUE obj)
+{
+  return FIX2ULONG(obj);
+}
+
+VALUE
+impl_long2fix(long val)
+{
+  return LONG2FIX(val);
+}
+
+int
+impl_fixable(long val)
+{
+  return FIXABLE(val);
+}
+
+int
+impl_posfixable(unsigned long val)
+{
+  return POSFIXABLE(val);
+}
+
+long
+impl_num2long(VALUE obj)
+{
+  return NUM2LONG(obj);
+}
+
+unsigned long
+impl_num2ulong(VALUE obj)
+{
+  return NUM2ULONG(obj);
+}
+
+VALUE
+impl_long2num(long val)
+{
+  return LONG2NUM(val);
+}
+
+VALUE
+impl_ulong2num(unsigned long val)
+{
+  return ULONG2NUM(val);
+}
+
+VALUE
+impl_rb_obj_write(VALUE old, VALUE *slot, VALUE young)
+{
+  return rb_obj_write(old, slot, young, __FILE__, __LINE__);
+}
+
+VALUE
+impl_rb_obj_written(VALUE old, VALUE oldv, VALUE young)
+{
+  return rb_obj_written(old, oldv, young, __FILE__, __LINE__);
+}
+
+int impl_fl_able(VALUE obj)
+{
+  return RB_FL_ABLE(obj);
+}
+
+const char *
+impl_rstring_end(VALUE obj)
+{
+  return RSTRING_END(obj);
+}
+
+void *
+impl_rdata_ptr(VALUE obj)
+{
+  return DATA_PTR(obj);
+}
+
+void
+impl_rb_obj_freeze(VALUE obj)
+{
+  RB_OBJ_FREEZE(obj);
+}
+
+int
+impl_rb_obj_promoted(VALUE obj)
+{
+#ifdef RB_OBJ_PROMOTED
+  return RB_OBJ_PROMOTED(obj);
+#else
+  // TruffleRuby / engines without generational GC: objects are never "promoted".
+  (void)obj;
+  return 0;
+#endif
+}
+
+int
+impl_rb_obj_promoted_raw(VALUE obj)
+{
+#ifdef RB_OBJ_PROMOTED_RAW
+  return RB_OBJ_PROMOTED_RAW(obj);
+#else
+  (void)obj;
+  return 0;
+#endif
+}
+
+double impl_num2dbl(VALUE obj)
+{
+  return NUM2DBL(obj);
+}
+
+VALUE impl_dbl2num(double val)
+{
+  return DBL2NUM(val);
+}
+
+size_t impl_rhash_size(VALUE obj)
+{
+  return RHASH_SIZE(obj);
+}
+
+int impl_rhash_empty_p(VALUE obj)
+{
+  return RHASH_EMPTY_P(obj);
+}
+
+int impl_encoding_get(VALUE obj)
+{
+#ifdef ENCODING_GET
+  return ENCODING_GET(obj);
+#else
+  // TruffleRuby and other non-MRI engines: delegate to rb_enc_get_index,
+  // which is an exported function (unlike ENCODING_GET, which is an MRI macro
+  // that pokes RBasic.flags directly — a layout TruffleRuby doesn't share).
+  return rb_enc_get_index(obj);
+#endif
+}

data/ext/cargo-vendor/{rb-sys-0.9.117 → rb-sys-0.9.130}/src/stable_api/compiled.rs

@@ -2,7 +2,7 @@ use super::StableApiDefinition;
 use crate::{ruby_value_type, timeval, RUBY_API_VERSION_MAJOR, RUBY_API_VERSION_MINOR, VALUE};
 use std::{
     ffi::c_void,
-    os::raw::{c_char, c_long},
+    os::raw::{c_char, c_int, c_long},
     ptr::NonNull,
     time::Duration,
 };
@@ -21,6 +21,12 @@ extern "C" {
     #[link_name = "impl_rarray_const_ptr"]
     fn impl_rarray_const_ptr(ary: VALUE) -> *const VALUE;
 
+    #[link_name = "impl_rarray_aref"]
+    fn impl_rarray_aref(ary: VALUE, idx: c_long) -> VALUE;
+
+    #[link_name = "impl_rarray_aset"]
+    fn impl_rarray_aset(ary: VALUE, idx: c_long, val: VALUE);
+
     #[link_name = "impl_rbasic_class"]
     fn impl_rbasic_class(obj: VALUE) -> VALUE;
 
@@ -85,14 +91,86 @@ extern "C" {
     #[link_name = "impl_rtypeddata_p"]
     fn impl_rtypeddata_p(obj: VALUE) -> bool;
 
-    #[link_name = "impl_rtypeddata_embedded_p"]
-    fn impl_rtypeddata_embedded_p(obj: VALUE) -> bool;
-
     #[link_name = "impl_rtypeddata_type"]
     fn impl_rtypeddata_type(obj: VALUE) -> *const crate::rb_data_type_t;
 
     #[link_name = "impl_rtypeddata_get_data"]
     fn impl_rtypeddata_get_data(obj: VALUE) -> *mut c_void;
+
+    // Accessor functions
+    #[link_name = "impl_rstring_end"]
+    fn impl_rstring_end(obj: VALUE) -> *const c_char;
+
+    #[link_name = "impl_rdata_ptr"]
+    fn impl_rdata_ptr(obj: VALUE) -> *mut c_void;
+
+    #[link_name = "impl_rb_obj_freeze"]
+    fn impl_rb_obj_freeze(obj: VALUE);
+
+    #[link_name = "impl_rb_obj_promoted"]
+    fn impl_rb_obj_promoted(obj: VALUE) -> c_int;
+
+    #[link_name = "impl_rb_obj_promoted_raw"]
+    fn impl_rb_obj_promoted_raw(obj: VALUE) -> c_int;
+
+    #[link_name = "impl_num2dbl"]
+    fn impl_num2dbl(obj: VALUE) -> f64;
+
+    #[link_name = "impl_dbl2num"]
+    fn impl_dbl2num(val: f64) -> VALUE;
+
+    #[link_name = "impl_rhash_size"]
+    fn impl_rhash_size(obj: VALUE) -> usize;
+
+    #[link_name = "impl_rhash_empty_p"]
+    fn impl_rhash_empty_p(obj: VALUE) -> std::os::raw::c_int;
+
+    #[link_name = "impl_encoding_get"]
+    fn impl_encoding_get(obj: VALUE) -> std::os::raw::c_int;
+
+    #[link_name = "impl_fl_able"]
+    fn impl_fl_able(obj: VALUE) -> c_int;
+
+    // Symbol/ID conversion functions
+    #[link_name = "impl_id2sym"]
+    fn impl_id2sym(id: crate::ID) -> VALUE;
+
+    #[link_name = "impl_sym2id"]
+    fn impl_sym2id(obj: VALUE) -> crate::ID;
+
+    // Integer conversion functions
+    #[link_name = "impl_fix2long"]
+    fn impl_fix2long(obj: VALUE) -> c_long;
+
+    #[link_name = "impl_fix2ulong"]
+    fn impl_fix2ulong(obj: VALUE) -> std::os::raw::c_ulong;
+
+    #[link_name = "impl_long2fix"]
+    fn impl_long2fix(val: c_long) -> VALUE;
+
+    #[link_name = "impl_fixable"]
+    fn impl_fixable(val: c_long) -> std::os::raw::c_int;
+
+    #[link_name = "impl_posfixable"]
+    fn impl_posfixable(val: std::os::raw::c_ulong) -> std::os::raw::c_int;
+
+    #[link_name = "impl_num2long"]
+    fn impl_num2long(obj: VALUE) -> c_long;
+
+    #[link_name = "impl_num2ulong"]
+    fn impl_num2ulong(obj: VALUE) -> std::os::raw::c_ulong;
+
+    #[link_name = "impl_long2num"]
+    fn impl_long2num(val: c_long) -> VALUE;
+
+    #[link_name = "impl_ulong2num"]
+    fn impl_ulong2num(val: std::os::raw::c_ulong) -> VALUE;
+
+    #[link_name = "impl_rb_obj_write"]
+    fn impl_rb_obj_write(old: VALUE, slot: *mut VALUE, young: VALUE) -> VALUE;
+
+    #[link_name = "impl_rb_obj_written"]
+    fn impl_rb_obj_written(old: VALUE, oldv: VALUE, young: VALUE) -> VALUE;
 }
 
 pub struct Definition;
@@ -121,6 +199,16 @@ impl StableApiDefinition for Definition {
         impl_rarray_const_ptr(obj)
     }
 
+    #[inline]
+    unsafe fn rarray_aref(&self, obj: VALUE, idx: isize) -> VALUE {
+        impl_rarray_aref(obj, idx as c_long)
+    }
+
+    #[inline]
+    unsafe fn rarray_aset(&self, obj: VALUE, idx: isize, val: VALUE) {
+        impl_rarray_aset(obj, idx as c_long, val)
+    }
+
     #[inline]
     unsafe fn rbasic_class(&self, obj: VALUE) -> Option<NonNull<VALUE>> {
         NonNull::<VALUE>::new(impl_rbasic_class(obj) as _)
@@ -234,24 +322,131 @@ impl StableApiDefinition for Definition {
     }
 
     #[inline]
-    #[cfg(ruby_gte_3_3)]
-    unsafe fn rtypeddata_embedded_p(&self, obj: VALUE) -> bool {
-        impl_rtypeddata_embedded_p(obj)
+    unsafe fn rtypeddata_type(&self, obj: VALUE) -> *const crate::rb_data_type_t {
+        impl_rtypeddata_type(obj)
     }
 
     #[inline]
-    #[cfg(ruby_lt_3_3)]
-    unsafe fn rtypeddata_embedded_p(&self, _obj: VALUE) -> bool {
-        false
+    unsafe fn rtypeddata_get_data(&self, obj: VALUE) -> *mut c_void {
+        impl_rtypeddata_get_data(obj)
     }
 
     #[inline]
-    unsafe fn rtypeddata_type(&self, obj: VALUE) -> *const crate::rb_data_type_t {
-        impl_rtypeddata_type(obj)
+    fn id2sym(&self, id: crate::ID) -> VALUE {
+        unsafe { impl_id2sym(id) }
     }
 
     #[inline]
-    unsafe fn rtypeddata_get_data(&self, obj: VALUE) -> *mut c_void {
-        impl_rtypeddata_get_data(obj)
+    unsafe fn sym2id(&self, obj: VALUE) -> crate::ID {
+        impl_sym2id(obj)
+    }
+
+    #[inline]
+    fn fix2long(&self, obj: VALUE) -> c_long {
+        unsafe { impl_fix2long(obj) }
+    }
+
+    #[inline]
+    fn fix2ulong(&self, obj: VALUE) -> std::os::raw::c_ulong {
+        unsafe { impl_fix2ulong(obj) }
+    }
+
+    #[inline]
+    fn long2fix(&self, val: c_long) -> VALUE {
+        unsafe { impl_long2fix(val) }
+    }
+
+    #[inline]
+    fn fixable(&self, val: c_long) -> bool {
+        unsafe { impl_fixable(val) != 0 }
+    }
+
+    #[inline]
+    fn posfixable(&self, val: std::os::raw::c_ulong) -> bool {
+        unsafe { impl_posfixable(val) != 0 }
+    }
+
+    #[inline]
+    unsafe fn num2long(&self, obj: VALUE) -> c_long {
+        impl_num2long(obj)
+    }
+
+    #[inline]
+    unsafe fn num2ulong(&self, obj: VALUE) -> std::os::raw::c_ulong {
+        impl_num2ulong(obj)
+    }
+
+    #[inline]
+    fn long2num(&self, val: c_long) -> VALUE {
+        unsafe { impl_long2num(val) }
+    }
+
+    #[inline]
+    fn ulong2num(&self, val: std::os::raw::c_ulong) -> VALUE {
+        unsafe { impl_ulong2num(val) }
+    }
+
+    #[inline]
+    unsafe fn rb_obj_write(&self, old: VALUE, slot: *mut VALUE, young: VALUE) -> VALUE {
+        impl_rb_obj_write(old, slot, young)
+    }
+
+    #[inline]
+    unsafe fn rb_obj_written(&self, old: VALUE, oldv: VALUE, young: VALUE) -> VALUE {
+        impl_rb_obj_written(old, oldv, young)
+    }
+
+    #[inline]
+    fn fl_able(&self, obj: VALUE) -> bool {
+        unsafe { impl_fl_able(obj) != 0 }
+    }
+
+    #[inline]
+    unsafe fn rstring_end(&self, obj: VALUE) -> *const c_char {
+        impl_rstring_end(obj)
+    }
+
+    #[inline]
+    unsafe fn rdata_ptr(&self, obj: VALUE) -> *mut c_void {
+        impl_rdata_ptr(obj)
+    }
+
+    #[inline]
+    unsafe fn rb_obj_freeze(&self, obj: VALUE) {
+        impl_rb_obj_freeze(obj)
+    }
+
+    #[inline]
+    unsafe fn rb_obj_promoted(&self, obj: VALUE) -> bool {
+        impl_rb_obj_promoted(obj) != 0
+    }
+
+    #[inline]
+    unsafe fn rb_obj_promoted_raw(&self, obj: VALUE) -> bool {
+        impl_rb_obj_promoted_raw(obj) != 0
+    }
+    #[inline]
+    unsafe fn num2dbl(&self, obj: VALUE) -> std::os::raw::c_double {
+        impl_num2dbl(obj)
+    }
+
+    #[inline]
+    fn dbl2num(&self, val: std::os::raw::c_double) -> VALUE {
+        unsafe { impl_dbl2num(val) }
+    }
+
+    #[inline]
+    unsafe fn rhash_size(&self, obj: VALUE) -> usize {
+        impl_rhash_size(obj)
+    }
+
+    #[inline]
+    unsafe fn rhash_empty_p(&self, obj: VALUE) -> bool {
+        impl_rhash_empty_p(obj) != 0
+    }
+
+    #[inline]
+    unsafe fn encoding_get(&self, obj: VALUE) -> std::os::raw::c_int {
+        impl_encoding_get(obj)
     }
 }