code_ownership 2.2.0 → 2.2.1

data/ext/cargo-vendor/{bindgen-0.69.5 → bindgen-0.72.1}/options/mod.rs

@@ -4,13 +4,15 @@
 #[macro_use]
 mod helpers;
 mod as_args;
+#[cfg(feature = "__cli")]
+pub(crate) mod cli;
 
 use crate::callbacks::ParseCallbacks;
 use crate::codegen::{
     AliasVariation, EnumVariation, MacroTypeVariation, NonCopyUnionStyle,
 };
 use crate::deps::DepfileSpec;
-use crate::features::{RustFeatures, RustTarget};
+use crate::features::{RustEdition, RustFeatures, RustTarget};
 use crate::regex_set::RegexSet;
 use crate::Abi;
 use crate::Builder;
@@ -21,9 +23,7 @@ use crate::HashMap;
 use crate::DEFAULT_ANON_FIELDS_PREFIX;
 
 use std::env;
-#[cfg(feature = "experimental")]
-use std::path::Path;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::rc::Rc;
 
 use as_args::AsArgs;
@@ -37,20 +37,20 @@ use helpers::ignore;
 /// a block of code with the following items:
 ///
 /// - `default`: The default value for the field. If this item is omitted, `Default::default()` is
-/// used instead, meaning that the type of the field must implement `Default`.
+///   used instead, meaning that the type of the field must implement `Default`.
 /// - `methods`: A block of code containing methods for the `Builder` type. These methods should be
-/// related to the field being declared.
+///   related to the field being declared.
 /// - `as_args`: This item declares how the field should be converted into a valid CLI argument for
-/// `bindgen` and is used in the [`Builder::command_line_flags`] method which is used to do a
-/// roundtrip test of the CLI args in the `bindgen-test` crate. This item can take one of the
-/// following:
+///   `bindgen` and is used in the [`Builder::command_line_flags`] method which is used to do a
+///   roundtrip test of the CLI args in the `bindgen-test` crate. This item can take one of the
+///   following:
 ///   - A string literal with the flag if the type of the field implements the [`AsArgs`] trait.
 ///   - A closure with the signature `|field, args: &mut Vec<String>| -> ()` that pushes arguments
-///   into the `args` buffer based on the value of the field. This is used if the field does not
-///   implement `AsArgs` or if the implementation of the trait is not logically correct for the
-///   option and a custom behavior must be taken into account.
+///     into the `args` buffer based on the value of the field. This is used if the field does not
+///     implement `AsArgs` or if the implementation of the trait is not logically correct for the
+///     option and a custom behavior must be taken into account.
 ///   - The `ignore` literal, which does not emit any CLI arguments for this field. This is useful
-///   if the field cannot be used from the `bindgen` CLI.
+///     if the field cannot be used from the `bindgen` CLI.
 ///
 /// As an example, this would be the declaration of a `bool` field called `be_fun` whose default
 /// value is `false` (the `Default` value for `bool`):
@@ -153,6 +153,64 @@ macro_rules! options {
 }
 
 options! {
+    /// Whether to specify the type of a virtual function receiver
+    use_specific_virtual_function_receiver: bool {
+        methods: {
+            /// Normally, virtual functions have void* as their 'this' type.
+            /// If this flag is enabled, override that behavior to indicate a
+            /// pointer of the specific type.
+            /// Disabled by default.
+            pub fn use_specific_virtual_function_receiver(mut self, doit: bool) -> Builder {
+                self.options.use_specific_virtual_function_receiver = doit;
+                self
+            }
+        },
+        as_args: "--use-specific-virtual-function-receiver",
+    },
+
+    /// Whether we should distinguish between C++'s 'char16_t' and 'u16'.
+    /// The C++ type `char16_t` is its own special type; it's not a typedef
+    /// of some other integer (this differs from C).
+    /// As standard, bindgen represents C++ `char16_t` as `u16`.
+    /// Rust does not have a `std::os::raw::c_char16_t` type, and thus
+    /// we can't use a built-in Rust type in the generated bindings (and
+    /// nor would it be appropriate as it's a C++-specific type.)
+    /// But for some uses of bindgen, especially when downstream
+    /// post-processing occurs, it's important to distinguish `char16_t`
+    /// from normal `uint16_t`. When this option is enabled, bindgen
+    /// generates a fake type called `bindgen_cchar16_t`. Downstream
+    /// code post-processors should arrange to replace this with a
+    /// real type.
+    use_distinct_char16_t: bool {
+        methods: {
+            /// If this is true, denote 'char16_t' as a separate type from 'u16'
+            /// Disabled by default.
+            pub fn use_distinct_char16_t(mut self, doit: bool) -> Builder {
+                self.options.use_distinct_char16_t = doit;
+                self
+            }
+        },
+        as_args: "--use-distinct-char16-t",
+    },
+    /// Whether we should output C++ overloaded operators. By itself,
+    /// this option is not sufficient to produce valid output, because
+    /// such operators will have names that are not acceptable Rust
+    /// names (for example `operator=`). If you use this option, you'll also
+    /// have to rename the resulting functions - for example by using
+    /// [`ParseCallbacks::generated_name_override`].
+    represent_cxx_operators: bool {
+        methods: {
+            /// If this is true, output existence of C++ overloaded operators.
+            /// At present, only operator= is noted.
+            /// Disabled by default.
+            pub fn represent_cxx_operators(mut self, doit: bool) -> Builder {
+                self.options.represent_cxx_operators = doit;
+                self
+            }
+        },
+        as_args: "--represent-cxx-operators",
+    },
+
     /// Types that have been blocklisted and should not appear anywhere in the generated code.
     blocklisted_types: RegexSet {
         methods: {
@@ -508,7 +566,7 @@ options! {
     constified_enums: RegexSet {
         methods: {
             regex_option! {
-                /// Mark the given `enum` as a set o integer constants.
+                /// Mark the given `enum` as a set of integer constants.
                 ///
                 /// This is similar to the [`Builder::constified_enum_module`] style, but the
                 /// constants are generated in the current module instead of in a new module.
@@ -1143,7 +1201,7 @@ options! {
         },
         as_args: |module_lines, args| {
             for (module, lines) in module_lines {
-                for line in lines.iter() {
+                for line in lines {
                     args.push("--module-raw-line".to_owned());
                     args.push(module.clone().into());
                     args.push(line.clone().into());
@@ -1179,6 +1237,35 @@ options! {
                 self.options.input_headers.push(header.into().into_boxed_str());
                 self
             }
+
+            /// Add input C/C++ header(s) to generate bindings for.
+            ///
+            /// This can be used to generate bindings for a single header:
+            ///
+            /// ```ignore
+            /// let bindings = bindgen::Builder::default()
+            ///     .headers(["input.h"])
+            ///     .generate()
+            ///     .unwrap();
+            /// ```
+            ///
+            /// Or for multiple headers:
+            ///
+            /// ```ignore
+            /// let bindings = bindgen::Builder::default()
+            ///     .headers(["first.h", "second.h", "third.h"])
+            ///     .generate()
+            ///     .unwrap();
+            /// ```
+            pub fn headers<I: IntoIterator>(mut self, headers: I) -> Builder
+            where
+                I::Item: Into<String>,
+            {
+                self.options
+                    .input_headers
+                    .extend(headers.into_iter().map(Into::into).map(Into::into));
+                self
+            }
         },
         // This field is handled specially inside the macro.
         as_args: ignore,
@@ -1205,6 +1292,11 @@ options! {
         // This field is handled specially inside the macro.
         as_args: ignore,
     },
+    /// The set of arguments to be passed straight through to Clang for the macro fallback code.
+    fallback_clang_args: Vec<Box<str>> {
+        methods: {},
+        as_args: ignore,
+    },
     /// Tuples of unsaved file contents of the form (name, contents).
     input_header_contents: Vec<(Box<str>, Box<str>)> {
         methods: {
@@ -1234,6 +1326,9 @@ options! {
     parse_callbacks: Vec<Rc<dyn ParseCallbacks>> {
         methods: {
             /// Add a new [`ParseCallbacks`] instance to configure types in different situations.
+            ///
+            /// This can also be used with [`CargoCallbacks`](struct@crate::CargoCallbacks) to emit
+            /// `cargo:rerun-if-changed=...` for all `#include`d header files.
             pub fn parse_callbacks(mut self, cb: Box<dyn ParseCallbacks>) -> Self {
                 self.options.parse_callbacks.push(Rc::from(cb));
                 self
@@ -1389,10 +1484,8 @@ options! {
             /// Note that they will usually not work. However you can use `-fkeep-inline-functions`
             /// or `-fno-inline-functions` if you are responsible of compiling the library to make
             /// them callable.
-            #[cfg_attr(
-                feature = "experimental",
-                doc = "\nCheck the [`Builder::wrap_static_fns`] method for an alternative."
-            )]
+            ///
+            /// Check the [`Builder::wrap_static_fns`] method for an alternative.
             pub fn generate_inline_functions(mut self, doit: bool) -> Self {
                 self.options.generate_inline_functions = doit;
                 self
@@ -1579,9 +1672,26 @@ options! {
             args.push(rust_target.to_string());
         },
     },
+    /// The Rust edition to use for code generation.
+    rust_edition: Option<RustEdition> {
+        methods: {
+            /// Specify the Rust target edition.
+            ///
+            /// The default edition is the latest edition supported by the chosen Rust target.
+            pub fn rust_edition(mut self, rust_edition: RustEdition) -> Self {
+                self.options.rust_edition = Some(rust_edition);
+                self
+            }
+        }
+        as_args: |edition, args| {
+            if let Some(edition) =  edition {
+                args.push("--rust-edition".to_owned());
+                args.push(edition.to_string());
+            }
+        },
+    },
     /// Features to be enabled. They are derived from `rust_target`.
     rust_features: RustFeatures {
-        default: RustTarget::default().into(),
         methods: {},
         // This field cannot be set from the CLI,
         as_args: ignore,
@@ -1814,7 +1924,7 @@ options! {
         },
         as_args: "--dynamic-loading",
     },
-    /// Whether to equire successful linkage for all routines in a shared library.
+    /// Whether to require successful linkage for all routines in a shared library.
     dynamic_link_require_all: bool {
         methods: {
             /// Set whether to require successful linkage for all routines in a shared library.
@@ -1879,7 +1989,7 @@ options! {
         },
         as_args: "--c-naming",
     },
-    /// Wether to always emit explicit padding fields.
+    /// Whether to always emit explicit padding fields.
     force_explicit_padding: bool {
         methods: {
             /// Set whether to always emit explicit padding fields.
@@ -1951,7 +2061,20 @@ options! {
         },
         as_args: "--wrap-unsafe-ops",
     },
-    /// Patterns for functions whose ABI should be overriden.
+    /// Use DSTs to represent structures with flexible array members.
+    flexarray_dst: bool {
+        methods: {
+            /// Use DSTs to represent structures with flexible array members.
+            ///
+            /// This option is disabled by default.
+            pub fn flexarray_dst(mut self, doit: bool) -> Self {
+                self.options.flexarray_dst = doit;
+                self
+            }
+        },
+        as_args: "--flexarray-dst",
+    },
+    /// Patterns for functions whose ABI should be overridden.
     abi_overrides: HashMap<Abi, RegexSet> {
         methods: {
             regex_option! {
@@ -1970,7 +2093,7 @@ options! {
             for (abi, set) in overrides {
                 for item in set.get_items() {
                     args.push("--override-abi".to_owned());
-                    args.push(format!("{}={}", item, abi));
+                    args.push(format!("{item}={abi}"));
                 }
             }
         },
@@ -1978,7 +2101,6 @@ options! {
     /// Whether to generate wrappers for `static` functions.
     wrap_static_fns: bool {
         methods: {
-            #[cfg(feature = "experimental")]
             /// Set whether to generate wrappers for `static`` functions.
             ///
             /// Passing `true` to this method will generate a C source file with non-`static`
@@ -1997,7 +2119,6 @@ options! {
     /// The suffix to be added to the function wrappers for `static` functions.
     wrap_static_fns_suffix: Option<String> {
         methods: {
-            #[cfg(feature = "experimental")]
             /// Set the suffix added to the wrappers for `static` functions.
             ///
             /// This option only comes into effect if `true` is passed to the
@@ -2014,7 +2135,6 @@ options! {
     /// The path of the file where the wrappers for `static` functions will be emitted.
     wrap_static_fns_path: Option<PathBuf> {
         methods: {
-            #[cfg(feature = "experimental")]
             /// Set the path for the source code file that would be created if any wrapper
             /// functions must be generated due to the presence of `static` functions.
             ///
@@ -2075,5 +2195,92 @@ options! {
             }
         },
         as_args: "--emit-diagnostics",
+    },
+    /// Whether to use Clang evaluation on temporary files as a fallback for macros that fail to
+    /// parse.
+    clang_macro_fallback: bool {
+        methods: {
+            /// Use Clang as a fallback for macros that fail to parse using `CExpr`.
+            ///
+            /// This uses a workaround to evaluate each macro in a temporary file. Because this
+            /// results in slower compilation, this option is opt-in.
+            pub fn clang_macro_fallback(mut self) -> Self {
+                self.options.clang_macro_fallback = true;
+                self
+            }
+        },
+        as_args: "--clang-macro-fallback",
     }
+    /// Path to use for temporary files created by clang macro fallback code like precompiled
+    /// headers.
+    clang_macro_fallback_build_dir: Option<PathBuf> {
+        methods: {
+            /// Set a path to a directory to which `.c` and `.h.pch` files should be written for the
+            /// purpose of using clang to evaluate macros that can't be easily parsed.
+            ///
+            /// The default location for `.h.pch` files is the directory that the corresponding
+            /// `.h` file is located in. The default for the temporary `.c` file used for clang
+            /// parsing is the current working directory. Both of these defaults are overridden
+            /// by this option.
+            pub fn clang_macro_fallback_build_dir<P: AsRef<Path>>(mut self, path: P) -> Self {
+                self.options.clang_macro_fallback_build_dir = Some(path.as_ref().to_owned());
+                self
+            }
+        },
+        as_args: "--clang-macro-fallback-build-dir",
+    }
+    /// Whether to always report C++ "deleted" functions.
+    generate_deleted_functions: bool {
+        methods: {
+            /// Set whether to generate C++ functions even marked "=deleted"
+            ///
+            /// Although not useful to call these functions, downstream code
+            /// generators may need to know whether they've been deleted in
+            /// order to determine the relocatability of a C++ type
+            /// (specifically by virtue of which constructors exist.)
+            pub fn generate_deleted_functions(mut self, doit: bool) -> Self {
+                self.options.generate_deleted_functions = doit;
+                self
+            }
+
+        },
+        as_args: "--generate-deleted-functions",
+    },
+    /// Whether to always report C++ "pure virtual" functions.
+    generate_pure_virtual_functions: bool {
+        methods: {
+            /// Set whether to generate C++ functions that are pure virtual.
+            ///
+            /// These functions can't be called, so the only reason
+            /// to generate them is if downstream postprocessors
+            /// need to know of their existence. This is necessary,
+            /// for instance, to determine whether a type itself is
+            /// pure virtual and thus can't be allocated.
+            /// Downstream code generators may choose to make code to
+            /// allow types to be allocated but need to avoid doing so
+            /// if the type contains pure virtual functions.
+            pub fn generate_pure_virtual_functions(mut self, doit: bool) -> Self {
+                self.options.generate_pure_virtual_functions = doit;
+                self
+            }
+
+        },
+        as_args: "--generate-pure-virtual-functions",
+    },
+    /// Whether to always report C++ "private" functions.
+    generate_private_functions: bool {
+        methods: {
+            /// Set whether to generate C++ functions that are private.
+            ///
+            /// These functions can't be called, so the only reason
+            /// to generate them is if downstream postprocessors
+            /// need to know of their existence.
+            pub fn generate_private_functions(mut self, doit: bool) -> Self {
+                self.options.generate_private_functions = doit;
+                self
+            }
+
+        },
+        as_args: "--generate-private-functions",
+    },
 }

data/ext/cargo-vendor/{bindgen-0.69.5 → bindgen-0.72.1}/regex_set.rs

@@ -6,7 +6,7 @@ use std::cell::Cell;
 
 /// A dynamic set of regular expressions.
 #[derive(Clone, Debug, Default)]
-pub struct RegexSet {
+pub(crate) struct RegexSet {
     items: Vec<Box<str>>,
     /// Whether any of the items in the set was ever matched. The length of this
     /// vector is exactly the length of `items`.
@@ -17,18 +17,13 @@ pub struct RegexSet {
 }
 
 impl RegexSet {
-    /// Create a new RegexSet
-    pub fn new() -> RegexSet {
-        RegexSet::default()
-    }
-
     /// Is this set empty?
-    pub fn is_empty(&self) -> bool {
+    pub(crate) fn is_empty(&self) -> bool {
         self.items.is_empty()
     }
 
     /// Insert a new regex into this set.
-    pub fn insert<S>(&mut self, string: S)
+    pub(crate) fn insert<S>(&mut self, string: S)
     where
         S: AsRef<str>,
     {
@@ -38,13 +33,13 @@ impl RegexSet {
     }
 
     /// Returns slice of String from its field 'items'
-    pub fn get_items(&self) -> &[Box<str>] {
+    pub(crate) fn get_items(&self) -> &[Box<str>] {
         &self.items
     }
 
     /// Returns an iterator over regexes in the set which didn't match any
     /// strings yet.
-    pub fn unmatched_items(&self) -> impl Iterator<Item = &str> {
+    pub(crate) fn unmatched_items(&self) -> impl Iterator<Item = &str> {
         self.items.iter().enumerate().filter_map(move |(i, item)| {
             if !self.record_matches || self.matched[i].get() {
                 return None;
@@ -54,28 +49,29 @@ impl RegexSet {
         })
     }
 
-    /// Construct a RegexSet from the set of entries we've accumulated.
+    /// Construct a `RegexSet` from the set of entries we've accumulated.
     ///
     /// Must be called before calling `matches()`, or it will always return
     /// false.
     #[inline]
-    pub fn build(&mut self, record_matches: bool) {
-        self.build_inner(record_matches, None)
+    #[allow(unused)]
+    pub(crate) fn build(&mut self, record_matches: bool) {
+        self.build_inner(record_matches, None);
     }
 
     #[cfg(all(feature = "__cli", feature = "experimental"))]
-    /// Construct a RegexSet from the set of entries we've accumulated and emit diagnostics if the
+    /// Construct a `RegexSet` from the set of entries we've accumulated and emit diagnostics if the
     /// name of the regex set is passed to it.
     ///
     /// Must be called before calling `matches()`, or it will always return
     /// false.
     #[inline]
-    pub fn build_with_diagnostics(
+    pub(crate) fn build_with_diagnostics(
         &mut self,
         record_matches: bool,
         name: Option<&'static str>,
     ) {
-        self.build_inner(record_matches, name)
+        self.build_inner(record_matches, name);
     }
 
     #[cfg(all(not(feature = "__cli"), feature = "experimental"))]
@@ -90,7 +86,7 @@ impl RegexSet {
         record_matches: bool,
         name: Option<&'static str>,
     ) {
-        self.build_inner(record_matches, name)
+        self.build_inner(record_matches, name);
     }
 
     fn build_inner(
@@ -98,12 +94,12 @@ impl RegexSet {
         record_matches: bool,
         _name: Option<&'static str>,
     ) {
-        let items = self.items.iter().map(|item| format!("^({})$", item));
+        let items = self.items.iter().map(|item| format!("^({item})$"));
         self.record_matches = record_matches;
         self.set = match RxSet::new(items) {
             Ok(x) => Some(x),
             Err(e) => {
-                warn!("Invalid regex in {:?}: {:?}", self.items, e);
+                warn!("Invalid regex in {:?}: {e:?}", self.items);
                 #[cfg(feature = "experimental")]
                 if let Some(name) = _name {
                     invalid_regex_warning(self, e, name);
@@ -114,14 +110,13 @@ impl RegexSet {
     }
 
     /// Does the given `string` match any of the regexes in this set?
-    pub fn matches<S>(&self, string: S) -> bool
+    pub(crate) fn matches<S>(&self, string: S) -> bool
     where
         S: AsRef<str>,
     {
         let s = string.as_ref();
-        let set = match self.set {
-            Some(ref set) => set,
-            None => return false,
+        let Some(ref set) = self.set else {
+            return false;
         };
 
         if !self.record_matches {
@@ -132,7 +127,7 @@ impl RegexSet {
         if !matches.matched_any() {
             return false;
         }
-        for i in matches.iter() {
+        for i in &matches {
             self.matched[i].set(true);
         }
 
@@ -180,20 +175,20 @@ fn invalid_regex_warning(
 
                 diagnostic.with_title(
                     "Error while parsing a regular expression.",
-                    Level::Warn,
+                    Level::Warning,
                 );
             } else {
-                diagnostic.with_title(string, Level::Warn);
+                diagnostic.with_title(string, Level::Warning);
             }
         }
         err => {
             let err = err.to_string();
-            diagnostic.with_title(err, Level::Warn);
+            diagnostic.with_title(err, Level::Warning);
         }
     }
 
     diagnostic.add_annotation(
-        format!("This regular expression was passed via `{}`.", name),
+        format!("This regular expression was passed via `{name}`."),
         Level::Note,
     );
 

data/ext/cargo-vendor/{bindgen-0.69.5 → bindgen-0.72.1}/time.rs

@@ -29,23 +29,23 @@ impl<'a> Timer<'a> {
 
     /// Returns the time elapsed since the timer's creation
     pub fn elapsed(&self) -> Duration {
-        Instant::now() - self.start
+        self.start.elapsed()
     }
 
     fn print_elapsed(&mut self) {
         if self.output {
             let elapsed = self.elapsed();
             let time = (elapsed.as_secs() as f64) * 1e3 +
-                (elapsed.subsec_nanos() as f64) / 1e6;
+                f64::from(elapsed.subsec_nanos()) / 1e6;
             let stderr = io::stderr();
             // Arbitrary output format, subject to change.
-            writeln!(stderr.lock(), "  time: {:>9.3} ms.\t{}", time, self.name)
+            writeln!(stderr.lock(), "  time: {time:>9.3} ms.\t{}", self.name)
                 .expect("timer write should not fail");
         }
     }
 }
 
-impl<'a> Drop for Timer<'a> {
+impl Drop for Timer<'_> {
     fn drop(&mut self) {
         self.print_elapsed();
     }

data/ext/cargo-vendor/rb-sys-0.9.130/.cargo-checksum.json

@@ -0,0 +1 @@
+{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"6b6285a9f4f75e8f8ac1d179a8f6b5c38f357ebde5adcef52f6bf8cb605af662","Cargo.lock":"02a2193b99dc3021579b45c7e0994243338592b29582e7506b3ed0f3a5425075","Cargo.toml":"a8273e6d112d52e711dc8d2cfbdb659c562620be06e88ea0af1b26a2f34bcaf0","Cargo.toml.orig":"cc5f74ebf87bc8cafbea2b06ddc4d2d36d912d3e80e72cb3fcbfeac3671c060b","LICENSE-APACHE":"110a4b771805962e964448aed69e868cc3e9aec91e89c88b8598f8bd726d1d6a","LICENSE-MIT":"3edf6db4f22b0da400397c3ffe917b3330f6cff051753ba02de9b40b4b8ccb24","bin/release.sh":"13e6ec69a0f03cbc9886802ddd6c41837e6211808bd2cb9d9b65dc5bfd0b5502","build/features.rs":"8bcc8f74a9b2bcdf2014fad977dc8c373a0c38ba780b9122d336ade7cc6b0cbc","build/main.rs":"6cecf1c716151f34d55151f9a80a33cd01b3f2a3be1358d243c6879ee9acdbe5","build/stable_api_config.rs":"4a2491c54680ea8a745b31e3904535b97910d19aed76d4bfdebb5e3654931ff2","build/version.rs":"a4f8c110683dd4a9bee4f7789e9ba86ab15181331ca96fb3f7a148960b093da8","readme.md":"b5fd9a041f53aeed0d71e4b3a85e4387ecc3aff11485b0fd44d5ef67d4fb4f2c","src/bindings.rs":"a0f182917bdaa5f2f889258ea6fcc7fc80cc0f07cfe5e780e0d3e8eda5381c46","src/hidden.rs":"9d502b26b5be29b89990dbe39e72b0c40811eb3417435edf2129019922df281e","src/lib.rs":"69c4cc6141c9e1d2d0a34465584f39dabb504d6c5cb219aaaad76bf4d978fdf6","src/macros.rs":"17ea949a7f055cccd4fc687a6e35cbec0ffe0650e0dd4702e3a72ab56190b581","src/memory.rs":"8cf337256bd8f109ae5e025262a13e410255d7492a0aedc1ce607ac99ae75315","src/ruby_abi_version.rs":"5cc660b2de3ba8e12e365b519a3130bec7ccb64914fa817cbe69ecc55a811bdc","src/special_consts.rs":"049185afcd776314daf821b4d650da6a88ff852e5475930cddac0511f5564124","src/stable_api.rs":"604ef5a1e340e4e1a2f8f6ac7e82bf32c2cdd8bd14416df54699e97ad91561d5","src/stable_api/compiled.c":"6ac83cde82b19590c334391c9d19e09975db743929863cf4024e816722e1d239","src/stable_api/compiled.rs":"2cee2c2700826252b3b323f6a2a7cf42e43ec318d7a6ef98c001302db192d220","src/stable_api/ruby_2_7.rs":"a1d928f1e9fa6bc980e7ad91553802a995a120d3735465c3a49cef6f226f71d3","src/stable_api/ruby_3_0.rs":"810ffa1c03691dea9751118f8d099c914479afb593b0eb16f3e0765be7f1d0c0","src/stable_api/ruby_3_1.rs":"5963a43a2ca26c9ddadd3f7ee9a0a9516a58e0ec7e65db4051997faebf5ffc45","src/stable_api/ruby_3_2.rs":"9d217fb29868be6404fc3b680fb4738d213eb6cff5e80ff83c02712c14f2a8a2","src/stable_api/ruby_3_3.rs":"03510ee5f0199e4b6fe6f9d0371ac7aa6337952c3d22236a8b6bcaaaa94c179e","src/stable_api/ruby_3_4.rs":"89e33d691928c114f974ef9ee9760ca3b6bd45b6c6f98016155f654e646dd619","src/stable_api/ruby_4_0.rs":"e2acfe8c84d00636c076b23cab3fc8a27efff5e74851c688eafa44ba4330394a","src/symbol.rs":"0b9eda6442a5cd2279cefcdacc1ae327c3c72254d703364f99ed1ff27a6b94b8","src/tracking_allocator.rs":"449bec90afea3e17234bb567ea596050c7d240fad034b66c0a9040e45950c4c7","src/utils.rs":"58911baeceb82fe484982949697ed1c81aafcc8b963b23ce81a742d8a4e4871a","src/value_type.rs":"dce790c49d3864f960c2fb93a8d906cfad0f48de258718177ceaa9fbf304b2eb"},"package":"02faf625bb10ba893e3ae620f19c9fb1b5f8fcae0fe4eb86bb3f2230fad75edb"}

data/ext/cargo-vendor/rb-sys-0.9.130/.cargo_vcs_info.json

@@ -0,0 +1,6 @@
+{
+  "git": {
+    "sha1": "020a6c284516fc56ec171164be70705f7329aadd"
+  },
+  "path_in_vcs": "crates/rb-sys"
+}