wasmtime 20.0.2 → 21.0.1

data/ext/cargo-vendor/postcard-1.0.8/tests/crc.rs

@@ -0,0 +1,60 @@
+#[test]
+#[cfg(feature = "use-crc")]
+fn test_crc() {
+    use crc::{Crc, CRC_32_ISCSI};
+
+    let data: &[u8] = &[0x01, 0x00, 0x20, 0x30];
+    let buffer = &mut [0u8; 32];
+    let crc = Crc::<u32>::new(&CRC_32_ISCSI);
+    let digest = crc.digest();
+    let res = postcard::to_slice_crc32(data, buffer, digest).unwrap();
+    assert_eq!(res, &[0x04, 0x01, 0x00, 0x20, 0x30, 0x8E, 0xC8, 0x1A, 0x37]);
+
+    let digest = crc.digest();
+    let res = postcard::take_from_bytes_crc32::<[u8; 5]>(&res, digest).unwrap();
+
+    let expected_bytes = [0x04, 0x01, 0x00, 0x20, 0x30];
+    let remaining_bytes = [];
+    assert_eq!(res, (expected_bytes, remaining_bytes.as_slice()));
+}
+
+#[test]
+#[cfg(feature = "use-crc")]
+fn test_crc_8() {
+    use crc::{Crc, CRC_8_SMBUS};
+
+    let data: &[u8] = &[0x01, 0x00, 0x20, 0x30];
+    let buffer = &mut [0u8; 32];
+    let crc = Crc::<u8>::new(&CRC_8_SMBUS);
+    let digest = crc.digest();
+    let res = postcard::ser_flavors::crc::to_slice_u8(data, buffer, digest).unwrap();
+    assert_eq!(res, &[0x04, 0x01, 0x00, 0x20, 0x30, 167]);
+
+    let digest = crc.digest();
+    let res = postcard::de_flavors::crc::take_from_bytes_u8::<[u8; 5]>(&res, digest).unwrap();
+
+    let expected_bytes = [0x04, 0x01, 0x00, 0x20, 0x30];
+    let remaining_bytes = [];
+    assert_eq!(res, (expected_bytes, remaining_bytes.as_slice()));
+}
+
+#[test]
+#[cfg(feature = "use-crc")]
+fn test_crc_error() {
+    use crc::{Crc, CRC_32_ISCSI};
+
+    let data: &[u8] = &[0x01, 0x00, 0x20, 0x30];
+    let buffer = &mut [0u8; 32];
+    let crc = Crc::<u32>::new(&CRC_32_ISCSI);
+    let digest = crc.digest();
+    let res = postcard::to_slice_crc32(data, buffer, digest).unwrap();
+
+    // intentionally corrupt the crc
+    let last = res.len() - 1;
+    res[last] = 0;
+
+    let digest = crc.digest();
+    let res = postcard::take_from_bytes_crc32::<[u8; 5]>(&res, digest);
+
+    assert_eq!(res, Err(postcard::Error::DeserializeBadCrc));
+}

data/ext/cargo-vendor/postcard-1.0.8/tests/loopback.rs

@@ -0,0 +1,248 @@
+use core::fmt::Debug;
+use core::fmt::Write;
+use core::ops::Deref;
+
+#[cfg(feature = "heapless")]
+use heapless::{FnvIndexMap, String, Vec};
+
+#[cfg(feature = "heapless")]
+use postcard::to_vec;
+
+use postcard::from_bytes;
+use serde::de::DeserializeOwned;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize, Eq, PartialEq)]
+struct BasicU8S {
+    st: u16,
+    ei: u8,
+    sf: u64,
+    tt: u32,
+}
+
+#[allow(dead_code)]
+#[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
+enum BasicEnum {
+    Bib,
+    Bim,
+    Bap,
+}
+
+#[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
+struct EnumStruct {
+    eight: u8,
+    sixt: u16,
+}
+
+#[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
+enum DataEnum {
+    Bib(u16),
+    Bim(u64),
+    Bap(u8),
+    Kim(EnumStruct),
+    Chi { a: u8, b: u32 },
+    Sho(u16, u8),
+}
+
+#[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
+struct NewTypeStruct(u32);
+
+#[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
+struct TupleStruct((u8, u16));
+
+#[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
+struct RefStruct<'a> {
+    bytes: &'a [u8],
+    str_s: &'a str,
+}
+
+#[cfg(feature = "heapless")]
+#[test]
+fn loopback() {
+    // Basic types
+    test_one((), &[]);
+    test_one(false, &[0x00]);
+    test_one(true, &[0x01]);
+    test_one(5u8, &[0x05]);
+    test_one(0xA5C7u16, &[0xC7, 0xCB, 0x02]);
+    test_one(0xCDAB3412u32, &[0x92, 0xE8, 0xAC, 0xED, 0x0C]);
+    test_one(
+        0x1234_5678_90AB_CDEFu64,
+        &[0xEF, 0x9B, 0xAF, 0x85, 0x89, 0xCF, 0x95, 0x9A, 0x12],
+    );
+
+    // https://github.com/jamesmunns/postcard/pull/83
+    test_one(32767i16, &[0xFE, 0xFF, 0x03]);
+    test_one(-32768i16, &[0xFF, 0xFF, 0x03]);
+
+    // chars
+    test_one('z', &[0x01, 0x7a]);
+    test_one('¢', &[0x02, 0xc2, 0xa2]);
+    test_one('𐍈', &[0x04, 0xF0, 0x90, 0x8D, 0x88]);
+    test_one('🥺', &[0x04, 0xF0, 0x9F, 0xA5, 0xBA]);
+
+    // Structs
+    test_one(
+        BasicU8S {
+            st: 0xABCD,
+            ei: 0xFE,
+            sf: 0x1234_4321_ABCD_DCBA,
+            tt: 0xACAC_ACAC,
+        },
+        &[
+            0xCD, 0xD7, 0x02, 0xFE, 0xBA, 0xB9, 0xB7, 0xDE, 0x9A, 0xE4, 0x90, 0x9A, 0x12, 0xAC,
+            0xD9, 0xB2, 0xE5, 0x0A,
+        ],
+    );
+
+    // Enums!
+    test_one(BasicEnum::Bim, &[0x01]);
+    test_one(
+        DataEnum::Bim(u64::max_value()),
+        &[
+            0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01,
+        ],
+    );
+    test_one(DataEnum::Bib(u16::max_value()), &[0x00, 0xFF, 0xFF, 0x03]);
+    test_one(DataEnum::Bap(u8::max_value()), &[0x02, 0xFF]);
+    test_one(
+        DataEnum::Kim(EnumStruct {
+            eight: 0xF0,
+            sixt: 0xACAC,
+        }),
+        &[0x03, 0xF0, 0xAC, 0xD9, 0x02],
+    );
+    test_one(
+        DataEnum::Chi {
+            a: 0x0F,
+            b: 0xC7C7C7C7,
+        },
+        &[0x04, 0x0F, 0xC7, 0x8F, 0x9F, 0xBE, 0x0C],
+    );
+    test_one(DataEnum::Sho(0x6969, 0x07), &[0x05, 0xE9, 0xD2, 0x01, 0x07]);
+
+    // Tuples!
+    test_one((0x12u8, 0xC7A5u16), &[0x12, 0xA5, 0x8F, 0x03]);
+
+    // Structs!
+    test_one(NewTypeStruct(5), &[0x05]);
+    test_one(TupleStruct((0xA0, 0x1234)), &[0xA0, 0xB4, 0x24]);
+
+    let mut input: Vec<u8, 4> = Vec::new();
+    input.extend_from_slice(&[0x01, 0x02, 0x03, 0x04]).unwrap();
+    test_one(input, &[0x04, 0x01, 0x02, 0x03, 0x04]);
+
+    let mut input: String<8> = String::new();
+    write!(&mut input, "helLO!").unwrap();
+    test_one(input, &[0x06, b'h', b'e', b'l', b'L', b'O', b'!']);
+
+    let mut input: FnvIndexMap<u8, u8, 4> = FnvIndexMap::new();
+    input.insert(0x01, 0x05).unwrap();
+    input.insert(0x02, 0x06).unwrap();
+    input.insert(0x03, 0x07).unwrap();
+    input.insert(0x04, 0x08).unwrap();
+    test_one(
+        input,
+        &[0x04, 0x01, 0x05, 0x02, 0x06, 0x03, 0x07, 0x04, 0x08],
+    );
+
+    // `CString` (uses `serialize_bytes`/`deserialize_byte_buf`)
+    #[cfg(feature = "use-std")]
+    test_one(
+        std::ffi::CString::new("heLlo").unwrap(),
+        &[0x05, b'h', b'e', b'L', b'l', b'o'],
+    );
+}
+
+#[cfg(feature = "heapless")]
+#[track_caller]
+fn test_one<'a, 'de, T>(data: T, ser_rep: &'a [u8])
+where
+    T: Serialize + DeserializeOwned + Eq + PartialEq + Debug,
+{
+    let serialized: Vec<u8, 2048> = to_vec(&data).unwrap();
+    assert_eq!(serialized.len(), ser_rep.len());
+    let mut x: ::std::vec::Vec<u8> = vec![];
+    x.extend(serialized.deref().iter().cloned());
+    // let bysl: &'de [u8] = serialized.deref();
+    assert_eq!(x, ser_rep);
+    {
+        // let deserialized: T = from_bytes(serialized.deref()).unwrap();
+        let deserialized: T = from_bytes(&x).unwrap();
+        assert_eq!(data, deserialized);
+    }
+}
+
+#[cfg(feature = "use-std")]
+#[test]
+fn std_io_loopback() {
+    use postcard::from_io;
+    use postcard::to_io;
+
+    fn test_io<'a, 'de, T>(data: T, ser_rep: &'a [u8])
+    where
+        T: Serialize + DeserializeOwned + Eq + PartialEq + Debug,
+    {
+        let serialized: ::std::vec::Vec<u8> = vec![];
+        let ser = to_io(&data, serialized).unwrap();
+        assert_eq!(ser.len(), ser_rep.len());
+        assert_eq!(ser, ser_rep);
+        {
+            let mut buff = [0; 2048];
+            let x = ser.clone();
+            let deserialized: T = from_io((x.as_slice(), &mut buff)).unwrap().0;
+            assert_eq!(data, deserialized);
+        }
+    }
+
+    test_io(DataEnum::Sho(0x6969, 0x07), &[0x05, 0xE9, 0xD2, 0x01, 0x07]);
+    test_io(
+        BasicU8S {
+            st: 0xABCD,
+            ei: 0xFE,
+            sf: 0x1234_4321_ABCD_DCBA,
+            tt: 0xACAC_ACAC,
+        },
+        &[
+            0xCD, 0xD7, 0x02, 0xFE, 0xBA, 0xB9, 0xB7, 0xDE, 0x9A, 0xE4, 0x90, 0x9A, 0x12, 0xAC,
+            0xD9, 0xB2, 0xE5, 0x0A,
+        ],
+    );
+}
+
+#[cfg(all(feature = "embedded-io", feature = "alloc"))]
+#[test]
+fn std_eio_loopback() {
+    use postcard::from_eio;
+    use postcard::to_eio;
+
+    fn test_io<'a, 'de, T>(data: T, ser_rep: &'a [u8])
+    where
+        T: Serialize + DeserializeOwned + Eq + PartialEq + Debug,
+    {
+        let serialized: ::std::vec::Vec<u8> = vec![];
+        let ser = to_eio(&data, serialized).unwrap();
+        assert_eq!(ser.len(), ser_rep.len());
+        assert_eq!(ser, ser_rep);
+        {
+            let mut buff = [0; 2048];
+            let x = ser.clone();
+            let deserialized: T = from_eio((x.as_slice(), &mut buff)).unwrap().0;
+            assert_eq!(data, deserialized);
+        }
+    }
+
+    test_io(DataEnum::Sho(0x6969, 0x07), &[0x05, 0xE9, 0xD2, 0x01, 0x07]);
+    test_io(
+        BasicU8S {
+            st: 0xABCD,
+            ei: 0xFE,
+            sf: 0x1234_4321_ABCD_DCBA,
+            tt: 0xACAC_ACAC,
+        },
+        &[
+            0xCD, 0xD7, 0x02, 0xFE, 0xBA, 0xB9, 0xB7, 0xDE, 0x9A, 0xE4, 0x90, 0x9A, 0x12, 0xAC,
+            0xD9, 0xB2, 0xE5, 0x0A,
+        ],
+    );
+}

data/ext/cargo-vendor/postcard-1.0.8/tests/max_size.rs

@@ -0,0 +1,101 @@
+#![allow(unused_imports)]
+
+#[cfg(feature = "experimental-derive")]
+mod tests {
+    use postcard::experimental::max_size::MaxSize;
+    use postcard::to_slice;
+    use serde::Serialize;
+
+    #[test]
+    fn test_struct_max_size() {
+        #[derive(MaxSize)]
+        struct Foo {
+            _a: u16,
+            _b: Option<u8>,
+        }
+
+        assert_eq!(Foo::POSTCARD_MAX_SIZE, 5);
+    }
+
+    #[test]
+    fn test_enum_max_size() {
+        #[allow(dead_code)]
+        #[derive(MaxSize, Serialize)]
+        enum Bar {
+            A(u16),
+            B(u8),
+        }
+
+        assert_eq!(Bar::POSTCARD_MAX_SIZE, 4);
+        let mut buf = [0u8; 128];
+        let used = to_slice(&Bar::A(0xFFFF), &mut buf).unwrap();
+        assert!(
+            used.len() <= Bar::POSTCARD_MAX_SIZE,
+            "FAIL {} > {}",
+            used.len(),
+            Bar::POSTCARD_MAX_SIZE
+        );
+
+        #[derive(MaxSize)]
+        enum Baz {}
+
+        assert_eq!(Baz::POSTCARD_MAX_SIZE, 0);
+    }
+
+    #[test]
+    fn test_ref() {
+        #[allow(dead_code)]
+        #[derive(MaxSize)]
+        struct Foo {
+            a: &'static u32,
+        }
+    }
+
+    #[cfg(feature = "heapless")]
+    #[test]
+    fn test_vec_edge_cases() {
+        #[track_caller]
+        fn test_equals<const N: usize>(buf: &mut [u8]) {
+            let mut v = heapless::Vec::<u8, N>::new();
+            for _ in 0..N {
+                v.push(0).unwrap();
+            }
+
+            let serialized = postcard::to_slice(&v, buf).unwrap();
+
+            assert_eq!(heapless::Vec::<u8, N>::POSTCARD_MAX_SIZE, serialized.len());
+        }
+
+        let mut buf = [0; 16400];
+
+        test_equals::<1>(&mut buf);
+        test_equals::<2>(&mut buf);
+
+        test_equals::<127>(&mut buf);
+        test_equals::<128>(&mut buf);
+        test_equals::<129>(&mut buf);
+
+        test_equals::<16383>(&mut buf);
+        test_equals::<16384>(&mut buf);
+        test_equals::<16385>(&mut buf);
+    }
+
+    // #[cfg(feature = "experimental-derive")]
+    // #[test]
+    // fn test_union_max_size() {
+    //     #[derive(postcard::MaxSize)]
+    //     union Foo {
+    //         a: u16,
+    //         b: Option<u8>,
+    //     }
+    // }
+
+    // #[cfg(feature = "experimental-derive")]
+    // #[test]
+    // fn test_not_implemented() {
+    //     #[derive(postcard::MaxSize)]
+    //     struct Foo {
+    //         a: &'static str,
+    //     }
+    // }
+}

data/ext/cargo-vendor/postcard-1.0.8/tests/schema.rs

@@ -0,0 +1,107 @@
+#![cfg(feature = "derive")]
+
+use postcard::schema::{NamedType, NamedValue, NamedVariant, Schema, SdmTy, Varint};
+
+const U8_SCHEMA: NamedType = NamedType {
+    name: "u8",
+    ty: &SdmTy::U8,
+};
+const U32_SCHEMA: NamedType = NamedType {
+    name: "u32",
+    ty: &SdmTy::Varint(Varint::U32),
+};
+const U64_SCHEMA: NamedType = NamedType {
+    name: "u64",
+    ty: &SdmTy::Varint(Varint::U64),
+};
+
+const I16_SCHEMA: NamedType = NamedType {
+    name: "i16",
+    ty: &SdmTy::Varint(Varint::I16),
+};
+const I32_SCHEMA: NamedType = NamedType {
+    name: "i32",
+    ty: &SdmTy::Varint(Varint::I32),
+};
+
+#[allow(unused)]
+#[derive(Schema)]
+enum Inner {
+    Alpha,
+    Beta,
+    Gamma,
+    Delta(i32, i16),
+}
+
+#[allow(unused)]
+#[derive(Schema)]
+struct Outer {
+    a: u32,
+    b: u64,
+    c: u8,
+    d: Inner,
+    e: [u8; 10],
+}
+
+#[test]
+fn test_enum_serialize() {
+    assert_eq!(
+        &NamedType {
+            name: "Inner",
+            ty: &SdmTy::Enum(&[
+                &NamedVariant {
+                    name: "Alpha",
+                    ty: &SdmTy::UnitVariant
+                },
+                &NamedVariant {
+                    name: "Beta",
+                    ty: &SdmTy::UnitVariant
+                },
+                &NamedVariant {
+                    name: "Gamma",
+                    ty: &SdmTy::UnitVariant
+                },
+                &NamedVariant {
+                    name: "Delta",
+                    ty: &SdmTy::TupleVariant(&[&I32_SCHEMA, &I16_SCHEMA,])
+                },
+            ]),
+        },
+        Inner::SCHEMA
+    );
+}
+
+#[test]
+fn test_struct_serialize() {
+    assert_eq!(
+        &NamedType {
+            name: "Outer",
+            ty: &SdmTy::Struct(&[
+                &NamedValue {
+                    name: "a",
+                    ty: &U32_SCHEMA
+                },
+                &NamedValue {
+                    name: "b",
+                    ty: &U64_SCHEMA
+                },
+                &NamedValue {
+                    name: "c",
+                    ty: &U8_SCHEMA
+                },
+                &NamedValue {
+                    name: "d",
+                    ty: Inner::SCHEMA
+                },
+                &NamedValue {
+                    name: "e",
+                    ty: &NamedType {
+                        name: "[T; N]",
+                        ty: &SdmTy::Seq(&U8_SCHEMA),
+                    }
+                }
+            ]),
+        },
+        Outer::SCHEMA
+    );
+}

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

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"7c7b8d5f3628d079736506f2c79414559e4224d663241bbc0782b88ad6665671","LICENSE-APACHE":"110a4b771805962e964448aed69e868cc3e9aec91e89c88b8598f8bd726d1d6a","LICENSE-MIT":"3edf6db4f22b0da400397c3ffe917b3330f6cff051753ba02de9b40b4b8ccb24","bin/release.sh":"13e6ec69a0f03cbc9886802ddd6c41837e6211808bd2cb9d9b65dc5bfd0b5502","build/features.rs":"64771d14419fb8cec74d1c2ce1e55ed08d213ed7da63e2707a3f63267c081460","build/main.rs":"fdf59a8da87ff8e86628c990ccdcc12a78af37d06f223bd6f2d2563c2837bff7","build/stable_api_config.rs":"cecf0f9dd82e8baeac3419e23b3f303e78c346ae95eb5443a606c6918b6ad292","build/version.rs":"5aa269dfe31b723f3ebfc7ecf95f5ab210f97ccffc37ae80b780d1d7c3092066","readme.md":"231c3861b3536ad03e6078456663d87267b09a84d5d332883c8bd7ea16cf9522","src/bindings.rs":"44acf672931859e1ae3c2443901d8d4104e764a1dd4c76dde379ef09aa2266f0","src/hidden.rs":"d504f494f08eb23dc459a58a6f48dfcc342ed48b307b6d2e6d951cb3e603f090","src/lib.rs":"e2688b6f61f5d3013a4ff70603c7516bc50a2d3dd1a9f116f3f1bf8a4d871bdf","src/macros.rs":"efb0a9f8bc52e21f24edc9a353cb6e8621c020a75900bbd883649de78aba27da","src/memory.rs":"d09435cc62db3d155cefe124e78d965b36c73ce4f75eb041a0a6b1ce2488a0ed","src/ruby_abi_version.rs":"bdc3b36f81cabf11902e7124cfd7b5555e811ca9bda0315c73dc9596002af86b","src/special_consts.rs":"115c1ff7cf681e52755df5ac14e109cbc641c9a6cdb8e57ddb915fc33b5eb745","src/stable_api.rs":"254602abff584068be428f83d58d55f340e60453048282358fb394a56cb2a9c2","src/stable_api/compiled.c":"42793803ad072d333fad4f76d90ab0fa666a0e95940077d4bc4eeb04495245a1","src/stable_api/compiled.rs":"6579184bfa8d454f6281d62e80fe911062ffa2e72464f4538c3a727633983c01","src/stable_api/ruby_2_6.rs":"1e44889355c0b581126ef4d112966c1f9587c652d21d1058fda6b5752dce4a6f","src/stable_api/ruby_2_7.rs":"c6cc59ec2e9a4989174f87c108af4555ee633a7cceff0b4bf3a116e99d60a487","src/stable_api/ruby_3_0.rs":"8bd8bfe9d96a810838e1e39f2eecd7d994384002ff98b7b14b4ffa2dfaf16d61","src/stable_api/ruby_3_1.rs":"9654491e22d50f3e475c8e447ca049ae79218392c6c9fc1732f1ec772a0a099e","src/stable_api/ruby_3_2.rs":"ce298b347f04f6d9ff30cd293a3a1fcabdc7a0a1b05faae458cfd9f30e844ced","src/stable_api/ruby_3_3.rs":"ac99b81de0d7df6e2e2b1209c8ceb0beb5b27a3765e18d5c18674bebb17df07d","src/symbol.rs":"0b9eda6442a5cd2279cefcdacc1ae327c3c72254d703364f99ed1ff27a6b94b8","src/tracking_allocator.rs":"0cfe0652e27f8c363576e3a6c3f4fd580ddba630eae06eeb2b5f06b85e7f1c5d","src/utils.rs":"3a0629bf39377316a07927ee280f29c48635aaa4d7e22fbd2bb49e3a067ee8b6","src/value_type.rs":"dce790c49d3864f960c2fb93a8d906cfad0f48de258718177ceaa9fbf304b2eb"},"package":"87f2ba20be84b32fad6b0ce397764bcdd0f2dca4431cf7035f6a6721e5747565"}

data/ext/cargo-vendor/rb-sys-0.9.100/Cargo.toml

@@ -0,0 +1,58 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2018"
+rust-version = "1.65"
+name = "rb-sys"
+version = "0.9.100"
+build = "build/main.rs"
+links = "rb"
+description = "Rust bindings for the CRuby API"
+homepage = "https://github.com/oxidize-rb/rb-sys"
+documentation = "https://docs.rs/rb-sys"
+readme = "readme.md"
+categories = ["external-ffi-bindings"]
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/oxidize-rb/rb-sys"
+
+[lib]
+doctest = false
+
+[dev-dependencies.rusty-fork]
+version = "0.3.0"
+
+[build-dependencies.rb-sys-build]
+version = "0.9.100"
+
+[features]
+bindgen-deprecated-types = ["rb-sys-build/bindgen-deprecated-types"]
+bindgen-enable-function-attribute-detection = ["rb-sys-build/bindgen-enable-function-attribute-detection"]
+bindgen-impl-debug = ["rb-sys-build/bindgen-impl-debug"]
+bindgen-layout-tests = ["rb-sys-build/bindgen-layout-tests"]
+bindgen-rbimpls = ["rb-sys-build/bindgen-rbimpls"]
+bindgen-return-const-encoding-pointers = ["rb-sys-build/bindgen-return-const-encoding-pointers"]
+bindgen-sizet-is-usize = ["rb-sys-build/bindgen-sizet-is-usize"]
+default = []
+fuzz = []
+global-allocator = []
+link-ruby = []
+no-link-ruby = []
+ruby-macros = ["stable-api"]
+ruby-static = []
+stable-api = []
+stable-api-compiled-fallback = ["stable-api"]
+stable-api-compiled-force = []
+stable-api-compiled-testing = ["stable-api-compiled-fallback"]
+
+[lints.rust.unexpected_cfgs]
+level = "warn"
+priority = 0