code_ownership 2.2.0 → 2.2.1

data/ext/cargo-vendor/rb-sys-build-0.9.130/src/bindings/gc_stress.rs

@@ -0,0 +1,303 @@
+use proc_macro2::Span;
+use quote::quote;
+
+/// When the `gc-stress` feature is enabled, wrap all extern "C" functions
+/// with calls to `rb_gc_start()` before and after the real function call.
+/// This helps smoke out GC safety bugs in native extensions.
+///
+/// Functions that are excluded from wrapping:
+/// - `rb_gc_*` functions (would cause infinite recursion)
+/// - `ruby_x*` functions (memory allocators called during GC)
+/// - Variadic functions (can't forward varargs in Rust)
+pub fn wrap_functions_with_gc_stress(syntax: &mut syn::File) {
+    let mut new_items: Vec<syn::Item> = Vec::new();
+
+    for item in syntax.items.iter_mut() {
+        if let syn::Item::ForeignMod(foreign_mod) = item {
+            let mut kept_items = Vec::new();
+            let mut raw_fns = Vec::new();
+            let mut wrapper_fns = Vec::new();
+
+            for foreign_item in foreign_mod.items.drain(..) {
+                if let syn::ForeignItem::Fn(f) = foreign_item {
+                    let name = f.sig.ident.to_string();
+
+                    if should_skip(&name, &f) {
+                        kept_items.push(syn::ForeignItem::Fn(f));
+                        continue;
+                    }
+
+                    let (raw_fn, wrapper) = generate_wrapper(f);
+                    raw_fns.push(raw_fn);
+                    wrapper_fns.push(wrapper);
+                } else {
+                    kept_items.push(foreign_item);
+                }
+            }
+
+            // Put back the items that weren't wrapped
+            foreign_mod.items = kept_items;
+
+            // Create a new extern block for the raw (renamed) functions
+            if !raw_fns.is_empty() {
+                let mut raw_block = foreign_mod.clone();
+                raw_block.items = raw_fns.into_iter().map(syn::ForeignItem::Fn).collect();
+                new_items.push(syn::Item::ForeignMod(raw_block));
+            }
+
+            // Add the wrapper functions as top-level items
+            for wrapper in wrapper_fns {
+                new_items.push(syn::Item::Fn(wrapper));
+            }
+        }
+    }
+
+    // Add a private helper that calls rb_gc_start() — avoids redeclaring it
+    // in every wrapper function. rb_gc_start is already in the extern block
+    // so we just call it directly.
+    let gc_stress_helper: syn::Item = syn::parse_quote! {
+        #[doc(hidden)]
+        #[inline(never)]
+        unsafe fn __rb_sys_gc_stress() {
+            rb_gc_start();
+        }
+    };
+    new_items.insert(0, gc_stress_helper);
+
+    syntax.items.extend(new_items);
+}
+
+/// Functions verified against the Ruby C source to never allocate Ruby objects.
+/// Wrapping these with rb_gc_start() is wasteful — skip them for performance.
+const NON_ALLOCATING_FUNCTIONS: &[&str] = &[
+    // -- Predicate functions (_p suffix) --
+    "rb_obj_frozen_p",
+    "rb_block_given_p",
+    "rb_keyword_given_p",
+    "rb_fiber_alive_p",
+    "rb_proc_lambda_p",
+    "rb_mutex_locked_p",
+    "rb_method_basic_definition_p",
+    "rb_bigzero_p",
+    "rb_ary_shared_with_p",
+    "rb_class_inherited_p",
+    "rb_mod_include_p",
+    "rb_io_closed_p",
+    "rb_autoload_p",
+    "rb_enc_dummy_p",
+    "rb_enc_str_asciionly_p",
+    "rb_enc_unicode_p",
+    "rb_enc_symname_p",
+    "rb_symname_p",
+    "rb_reserved_fd_p",
+    "rb_memory_view_available_p",
+    "rb_absint_singlebit_p",
+    "rb_typeddata_inherited_p",
+    "rb_econv_has_convpath_p",
+    "rb_file_directory_p",
+    "rb_profile_frame_singleton_method_p",
+    "rb_tracepoint_enabled_p",
+    // -- Type checks / identity --
+    "rb_obj_is_kind_of",
+    "rb_obj_is_instance_of",
+    "rb_obj_is_proc",
+    "rb_obj_is_fiber",
+    "rb_obj_is_method",
+    "rb_typeddata_is_kind_of",
+    "rb_check_typeddata",
+    "rb_check_type",
+    // -- Class/object accessors --
+    "rb_obj_class",
+    "rb_obj_classname",
+    "rb_class_real",
+    "rb_class_get_superclass",
+    "rb_class_name",
+    "rb_class2name",
+    "rb_class_attached_object",
+    // -- Object state --
+    "rb_obj_freeze",
+    "rb_obj_setup",
+    // -- Symbol/ID --
+    "rb_sym2id",
+    "rb_id2name",
+    "rb_sym2str",
+    // -- Instance variable read --
+    "rb_ivar_get",
+    "rb_ivar_defined",
+    // -- String (non-allocating) --
+    "rb_str_length",
+    "rb_str_hash",
+    "rb_str_comparable",
+    "rb_str_cmp",
+    "rb_str_equal",
+    // -- Array (non-allocating) --
+    "rb_ary_entry",
+    "rb_ary_freeze",
+    // -- Hash (non-allocating) --
+    "rb_hash_lookup",
+    "rb_hash_lookup2",
+    "rb_hash_size",
+    "rb_hash_freeze",
+    // -- Struct (non-allocating) --
+    "rb_struct_size",
+    "rb_struct_getmember",
+    "rb_struct_aref",
+    // -- Encoding accessors --
+    "rb_enc_get_index",
+    "rb_enc_get",
+    "rb_enc_from_index",
+    "rb_enc_to_index",
+    "rb_enc_compatible",
+    "rb_enc_check",
+    "rb_usascii_encindex",
+    "rb_utf8_encindex",
+    "rb_ascii8bit_encindex",
+    // -- Numeric conversions --
+    "rb_num2long",
+    "rb_num2ulong",
+    "rb_num2int",
+    "rb_fix2int",
+    "rb_fix2uint",
+    "rb_num2short",
+    // -- Thread/fiber --
+    "rb_thread_current",
+    "rb_thread_main",
+    "rb_thread_local_aref",
+    "rb_thread_alone",
+    "rb_fiber_current",
+    // -- IO --
+    "rb_io_descriptor",
+    "rb_io_check_closed",
+    // -- Range --
+    "rb_range_beg_len",
+    "rb_range_values",
+    // -- Regexp --
+    "rb_reg_options",
+    // -- Control flow --
+    "rb_protect",
+    "rb_during_gc",
+    "rb_respond_to",
+    "rb_obj_respond_to",
+    // -- Source location --
+    "rb_sourcefile",
+    "rb_sourceline",
+    "rb_frame_this_func",
+    "rb_frame_callee",
+    // -- Profile frame (non-allocating subset) --
+    "rb_profile_frame_path",
+    "rb_profile_frame_label",
+    "rb_profile_frame_base_label",
+    // -- Memory view --
+    "rb_memory_view_get",
+];
+
+fn should_skip(name: &str, f: &syn::ForeignItemFn) -> bool {
+    // Skip GC functions to avoid infinite recursion
+    if name.starts_with("rb_gc_") {
+        return true;
+    }
+
+    // Skip memory allocators (called during GC)
+    if name.starts_with("ruby_x") {
+        return true;
+    }
+
+    // Skip variadic functions (can't forward varargs)
+    if f.sig.variadic.is_some() {
+        return true;
+    }
+
+    // Skip functions verified to never allocate Ruby objects
+    if NON_ALLOCATING_FUNCTIONS.contains(&name) {
+        return true;
+    }
+
+    false
+}
+
+fn generate_wrapper(mut f: syn::ForeignItemFn) -> (syn::ForeignItemFn, syn::ItemFn) {
+    let original_name = f.sig.ident.clone();
+    let original_name_str = original_name.to_string();
+    let raw_name = syn::Ident::new(
+        &format!("__rb_sys_raw_{}", original_name_str),
+        original_name.span(),
+    );
+
+    // Collect parameter names for forwarding
+    let param_names: Vec<_> = f
+        .sig
+        .inputs
+        .iter()
+        .enumerate()
+        .map(|(i, arg)| match arg {
+            syn::FnArg::Typed(pat_type) => {
+                if let syn::Pat::Ident(pat_ident) = &*pat_type.pat {
+                    pat_ident.ident.clone()
+                } else {
+                    syn::Ident::new(&format!("__arg{}", i), Span::call_site())
+                }
+            }
+            _ => syn::Ident::new(&format!("__arg{}", i), Span::call_site()),
+        })
+        .collect();
+
+    // Clone the original attrs (docs etc) for the wrapper
+    let wrapper_attrs = f.attrs.clone();
+
+    // Build the raw extern fn: rename + add #[link_name] + make non-pub
+    f.sig.ident = raw_name.clone();
+    f.vis = syn::Visibility::Inherited;
+    f.attrs
+        .push(syn::parse_quote! { #[link_name = #original_name_str] });
+
+    // Build the wrapper function
+    let wrapper_sig = {
+        let mut sig = f.sig.clone();
+        sig.ident = original_name;
+        sig.unsafety = Some(syn::token::Unsafe::default());
+        sig.abi = Some(syn::Abi {
+            extern_token: syn::token::Extern::default(),
+            name: Some(syn::LitStr::new("C", Span::call_site())),
+        });
+        sig
+    };
+
+    let returns_never =
+        matches!(&wrapper_sig.output, syn::ReturnType::Type(_, ty) if is_never_type(ty));
+    let has_return = !matches!(&wrapper_sig.output, syn::ReturnType::Default);
+
+    let call_expr = quote! { #raw_name(#(#param_names),*) };
+
+    let body: syn::Block = if returns_never {
+        syn::parse_quote! {{
+            __rb_sys_gc_stress();
+            #call_expr
+        }}
+    } else if has_return {
+        syn::parse_quote! {{
+            __rb_sys_gc_stress();
+            let __ret = #call_expr;
+            __rb_sys_gc_stress();
+            __ret
+        }}
+    } else {
+        syn::parse_quote! {{
+            __rb_sys_gc_stress();
+            #call_expr;
+            __rb_sys_gc_stress();
+        }}
+    };
+
+    let wrapper = syn::ItemFn {
+        attrs: wrapper_attrs,
+        vis: syn::parse_quote! { pub },
+        sig: wrapper_sig,
+        block: Box::new(body),
+    };
+
+    (f, wrapper)
+}
+
+fn is_never_type(ty: &syn::Type) -> bool {
+    matches!(ty, syn::Type::Never(_))
+}

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

@@ -6,10 +6,11 @@ use crate::RbConfig;
 
 const OPAQUE_STRUCTS: [&str; 4] = ["RString", "RArray", "RData", "RTypedData"];
 
-const OPAQUE_STRUCTS_RUBY_3_3: [&str; 3] = [
-    "rb_matchext_struct",
-    "rb_internal_thread_event_data",
-    "rb_io_internal_buffer",
+// (struct_name, added_in, removed_in) — removed_in is an exclusive upper bound (None = still present)
+const VERSIONED_OPAQUE_STRUCTS: &[(&str, (u32, u32), Option<(u32, u32)>)] = &[
+    ("rb_matchext_struct", (3, 3), Some((4, 1))), // removed in 4.1, merged into RMatch
+    ("rb_internal_thread_event_data", (3, 3), None),
+    ("rb_io_internal_buffer", (3, 3), None),
 ];
 
 /// Generate opaque structs for the given bindings.
@@ -138,6 +139,40 @@ pub fn categorize_bindings(syntax: &mut syn::File) {
         }
     }
 
+    // Fix const-based layout tests (bindgen 0.72+) that reference opaque
+    // struct types moved to stable/internal modules.
+    for item in excluded_items.iter_mut() {
+        if let syn::Item::Const(ref mut c) = item {
+            let code = c.expr.to_token_stream().to_string();
+            let references_opaque = code.contains("rb_sys__Opaque__")
+                || opaque_idents_to_swap.iter().any(|s| {
+                    code.contains(&format!("< {} >", s))
+                        || code.contains(&format!("< {} ,", s))
+                        || code.contains(&format!("! ({} ,", s))
+                });
+            if references_opaque {
+                let mut new_code = code.replace("rb_sys__Opaque__", "super::stable::");
+                for name in &opaque_idents_to_swap {
+                    new_code = new_code.replace(
+                        &format!("< {} >", name),
+                        &format!("< super::internal::{} >", name),
+                    );
+                    new_code = new_code.replace(
+                        &format!("< {} ,", name),
+                        &format!("< super::internal::{} ,", name),
+                    );
+                    new_code = new_code.replace(
+                        &format!("! ({} ,", name),
+                        &format!("! (super::internal::{} ,", name),
+                    );
+                }
+                if let Ok(new_expr) = syn::parse_str::<syn::Expr>(&new_code) {
+                    c.expr = Box::new(new_expr);
+                }
+            }
+        }
+    }
+
     *syntax = syn::parse_quote! {
         /// Contains all items that are not yet categorized by ABI stability.
         /// These items are candidates for promotion to `stable` or `unstable`
@@ -192,15 +227,71 @@ fn gen_opaque_struct(
 }
 
 fn get_version_specific_opaque_structs(major_minor: Option<(u32, u32)>) -> Vec<&'static str> {
-    let Some(major_minor) = major_minor else {
+    let Some(v) = major_minor else {
         return vec![];
     };
-    let mut result = vec![];
-    let (major, minor) = major_minor;
+    VERSIONED_OPAQUE_STRUCTS
+        .iter()
+        .filter(|(_, added, removed)| v >= *added && removed.map_or(true, |r| v < r))
+        .map(|(name, _, _)| *name)
+        .collect()
+}
 
-    if major == 3 && minor >= 3 {
-        result.extend(OPAQUE_STRUCTS_RUBY_3_3)
-    }
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_get_version_specific_opaque_structs() {
+        // No version info
+        assert!(get_version_specific_opaque_structs(None).is_empty());
+
+        // Ruby 3.2.x - too old for 3.3 structs
+        assert!(get_version_specific_opaque_structs(Some((3, 2))).is_empty());
+
+        // Ruby 3.3.x - all three structs present
+        assert_eq!(
+            get_version_specific_opaque_structs(Some((3, 3))),
+            vec![
+                "rb_matchext_struct",
+                "rb_internal_thread_event_data",
+                "rb_io_internal_buffer"
+            ]
+        );
 
-    result
+        // Ruby 3.4.x - same as 3.3
+        assert_eq!(
+            get_version_specific_opaque_structs(Some((3, 4))),
+            vec![
+                "rb_matchext_struct",
+                "rb_internal_thread_event_data",
+                "rb_io_internal_buffer"
+            ]
+        );
+
+        // Ruby 4.0.x - matchext still present
+        assert_eq!(
+            get_version_specific_opaque_structs(Some((4, 0))),
+            vec![
+                "rb_matchext_struct",
+                "rb_internal_thread_event_data",
+                "rb_io_internal_buffer"
+            ]
+        );
+
+        // Ruby 4.1.x - matchext removed (merged into RMatch in 4.1)
+        assert_eq!(
+            get_version_specific_opaque_structs(Some((4, 1))),
+            vec!["rb_internal_thread_event_data", "rb_io_internal_buffer"]
+        );
+
+        // Ruby 4.2.x - matchext still gone
+        assert_eq!(
+            get_version_specific_opaque_structs(Some((4, 2))),
+            vec!["rb_internal_thread_event_data", "rb_io_internal_buffer"]
+        );
+
+        // Ruby 2.7.x - too old
+        assert!(get_version_specific_opaque_structs(Some((2, 7))).is_empty());
+    }
 }

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

@@ -1,3 +1,5 @@
+#[cfg(feature = "gc-stress")]
+mod gc_stress;
 mod sanitizer;
 mod stable_api;
 
@@ -105,6 +107,16 @@ pub fn generate(
         }
 
         push_cargo_cfg_from_bindings(&tokens, cfg_out)?;
+
+        #[cfg(feature = "gc-stress")]
+        {
+            debug_log!(
+                "INFO: gc-stress feature enabled, wrapping extern C functions with rb_gc_start()"
+            );
+            println!("cargo:warning=rb-sys: gc-stress enabled — all Ruby C API functions are wrapped with rb_gc_start() calls");
+            gc_stress::wrap_functions_with_gc_stress(&mut tokens);
+        }
+
         categorize_bindings(&mut tokens);
         tokens.into_token_stream().to_string()
     };
@@ -140,20 +152,12 @@ fn clean_docs(rbconfig: &RbConfig, syntax: &mut syn::File) {
     })
 }
 
-fn default_bindgen(clang_args: Vec<String>, rbconfig: &RbConfig) -> bindgen::Builder {
-    // Disable layout tests and Debug impl for Ruby 2.7 and 3.0 on Windows MinGW due to type incompatibilities
-    let is_old_ruby_windows_mingw = if cfg!(target_os = "windows") && !is_msvc() {
-        if let Some((major, minor)) = rbconfig.major_minor() {
-            (major == 2 && minor == 7) || (major == 3 && minor == 0)
-        } else {
-            false
-        }
-    } else {
-        false
-    };
+fn default_bindgen(clang_args: Vec<String>, _rbconfig: &RbConfig) -> bindgen::Builder {
+    // Disable layout tests and Debug impl on Windows MinGW due to packed struct layout incompatibilities
+    let is_windows_mingw = cfg!(target_os = "windows") && !is_msvc();
 
-    let enable_layout_tests = !is_old_ruby_windows_mingw && cfg!(feature = "bindgen-layout-tests");
-    let impl_debug = !is_old_ruby_windows_mingw && cfg!(feature = "bindgen-impl-debug");
+    let enable_layout_tests = !is_windows_mingw && cfg!(feature = "bindgen-layout-tests");
+    let impl_debug = !is_windows_mingw && cfg!(feature = "bindgen-impl-debug");
 
     let mut bindings = bindgen::Builder::default()
         .rustified_enum(".*")
@@ -167,6 +171,8 @@ fn default_bindgen(clang_args: Vec<String>, rbconfig: &RbConfig) -> bindgen::Bui
         .blocklist_item("^__pthread_.*")
         .blocklist_item("^pthread_.*")
         .blocklist_item("^rb_native.*")
+        .blocklist_type("INET_PORT_RESERVATION_INSTANCE")
+        .blocklist_type("PINET_PORT_RESERVATION_INSTANCE")
         .opaque_type("^__sFILE$")
         .merge_extern_blocks(true)
         .generate_comments(true)

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

@@ -116,7 +116,7 @@ impl Build {
         let mut hasher = DefaultHasher::new();
         object_files
             .iter()
-            .for_each(|f| hasher.write(f.to_str().expect("non-utf8 filename").as_bytes()));
+            .for_each(|f| hasher.write(f.as_os_str().as_encoded_bytes()));
         let lib_name = format!("{}-{}", name, hasher.finish());
         let lib_filename = format!("lib{}.a", lib_name);
         let dst = out_dir.join(lib_filename);