html-to-markdown 2.23.4 → 2.24.1

data/rust-vendor/zerocopy-derive/src/output_tests/expected/eq.expected.rs

@@ -0,0 +1,17 @@
+impl<T: Clone> ::zerocopy::util::macro_util::core_reexport::cmp::PartialEq for Foo<T>
+where
+    Self: ::zerocopy::IntoBytes + ::zerocopy::Immutable,
+    Self: Sized,
+{
+    fn eq(&self, other: &Self) -> bool {
+        ::zerocopy::util::macro_util::core_reexport::cmp::PartialEq::eq(
+            ::zerocopy::IntoBytes::as_bytes(self),
+            ::zerocopy::IntoBytes::as_bytes(other),
+        )
+    }
+}
+impl<T: Clone> ::zerocopy::util::macro_util::core_reexport::cmp::Eq for Foo<T>
+where
+    Self: ::zerocopy::IntoBytes + ::zerocopy::Immutable,
+    Self: Sized,
+{}

data/rust-vendor/zerocopy-derive/src/output_tests/expected/from_bytes_enum.expected.rs

@@ -0,0 +1,64 @@
+#[allow(
+    deprecated,
+    private_bounds,
+    non_local_definitions,
+    non_camel_case_types,
+    non_upper_case_globals,
+    non_snake_case,
+    non_ascii_idents,
+    clippy::missing_inline_in_public_items,
+)]
+#[deny(ambiguous_associated_items)]
+#[automatically_derived]
+const _: () = {
+    unsafe impl ::zerocopy::TryFromBytes for Foo {
+        fn only_derive_is_allowed_to_implement_this_trait() {}
+        fn is_bit_valid(
+            _candidate: ::zerocopy::Maybe<Self>,
+        ) -> ::zerocopy::util::macro_util::core_reexport::primitive::bool {
+            if false {
+                fn assert_is_from_bytes<T>()
+                where
+                    T: ::zerocopy::FromBytes,
+                    T: ?::zerocopy::util::macro_util::core_reexport::marker::Sized,
+                {}
+                assert_is_from_bytes::<Self>();
+            }
+            true
+        }
+    }
+};
+#[allow(
+    deprecated,
+    private_bounds,
+    non_local_definitions,
+    non_camel_case_types,
+    non_upper_case_globals,
+    non_snake_case,
+    non_ascii_idents,
+    clippy::missing_inline_in_public_items,
+)]
+#[deny(ambiguous_associated_items)]
+#[automatically_derived]
+const _: () = {
+    unsafe impl ::zerocopy::FromZeros for Foo {
+        fn only_derive_is_allowed_to_implement_this_trait() {}
+    }
+};
+#[allow(
+    deprecated,
+    private_bounds,
+    non_local_definitions,
+    non_camel_case_types,
+    non_upper_case_globals,
+    non_snake_case,
+    non_ascii_idents,
+    clippy::missing_inline_in_public_items,
+)]
+#[deny(ambiguous_associated_items)]
+#[automatically_derived]
+const _: () = {
+    unsafe impl ::zerocopy::FromBytes for Foo {
+        fn only_derive_is_allowed_to_implement_this_trait() {}
+    }
+};

data/rust-vendor/zerocopy-derive/src/output_tests/expected/from_bytes_struct.expected.rs

@@ -0,0 +1,64 @@
+#[allow(
+    deprecated,
+    private_bounds,
+    non_local_definitions,
+    non_camel_case_types,
+    non_upper_case_globals,
+    non_snake_case,
+    non_ascii_idents,
+    clippy::missing_inline_in_public_items,
+)]
+#[deny(ambiguous_associated_items)]
+#[automatically_derived]
+const _: () = {
+    unsafe impl ::zerocopy::TryFromBytes for Foo {
+        fn only_derive_is_allowed_to_implement_this_trait() {}
+        fn is_bit_valid(
+            _candidate: ::zerocopy::Maybe<Self>,
+        ) -> ::zerocopy::util::macro_util::core_reexport::primitive::bool {
+            if false {
+                fn assert_is_from_bytes<T>()
+                where
+                    T: ::zerocopy::FromBytes,
+                    T: ?::zerocopy::util::macro_util::core_reexport::marker::Sized,
+                {}
+                assert_is_from_bytes::<Self>();
+            }
+            true
+        }
+    }
+};
+#[allow(
+    deprecated,
+    private_bounds,
+    non_local_definitions,
+    non_camel_case_types,
+    non_upper_case_globals,
+    non_snake_case,
+    non_ascii_idents,
+    clippy::missing_inline_in_public_items,
+)]
+#[deny(ambiguous_associated_items)]
+#[automatically_derived]
+const _: () = {
+    unsafe impl ::zerocopy::FromZeros for Foo {
+        fn only_derive_is_allowed_to_implement_this_trait() {}
+    }
+};
+#[allow(
+    deprecated,
+    private_bounds,
+    non_local_definitions,
+    non_camel_case_types,
+    non_upper_case_globals,
+    non_snake_case,
+    non_ascii_idents,
+    clippy::missing_inline_in_public_items,
+)]
+#[deny(ambiguous_associated_items)]
+#[automatically_derived]
+const _: () = {
+    unsafe impl ::zerocopy::FromBytes for Foo {
+        fn only_derive_is_allowed_to_implement_this_trait() {}
+    }
+};

data/rust-vendor/zerocopy-derive/src/output_tests/expected/from_bytes_union.expected.rs

@@ -0,0 +1,144 @@
+#[allow(
+    deprecated,
+    private_bounds,
+    non_local_definitions,
+    non_camel_case_types,
+    non_upper_case_globals,
+    non_snake_case,
+    non_ascii_idents,
+    clippy::missing_inline_in_public_items,
+)]
+#[deny(ambiguous_associated_items)]
+#[automatically_derived]
+const _: () = {
+    unsafe impl ::zerocopy::TryFromBytes for Foo
+    where
+        u8: ::zerocopy::TryFromBytes,
+    {
+        fn only_derive_is_allowed_to_implement_this_trait() {}
+        fn is_bit_valid(
+            _candidate: ::zerocopy::Maybe<Self>,
+        ) -> ::zerocopy::util::macro_util::core_reexport::primitive::bool {
+            if false {
+                fn assert_is_from_bytes<T>()
+                where
+                    T: ::zerocopy::FromBytes,
+                    T: ?::zerocopy::util::macro_util::core_reexport::marker::Sized,
+                {}
+                assert_is_from_bytes::<Self>();
+            }
+            true
+        }
+    }
+    #[allow(
+        deprecated,
+        private_bounds,
+        non_local_definitions,
+        non_camel_case_types,
+        non_upper_case_globals,
+        non_snake_case,
+        non_ascii_idents,
+        clippy::missing_inline_in_public_items,
+    )]
+    #[deny(ambiguous_associated_items)]
+    #[automatically_derived]
+    const _: () = {
+        enum ẕa {}
+        #[allow(
+            deprecated,
+            private_bounds,
+            non_local_definitions,
+            non_camel_case_types,
+            non_upper_case_globals,
+            non_snake_case,
+            non_ascii_idents,
+            clippy::missing_inline_in_public_items,
+        )]
+        #[deny(ambiguous_associated_items)]
+        #[automatically_derived]
+        const _: () = {
+            unsafe impl ::zerocopy::HasTag for Foo {
+                fn only_derive_is_allowed_to_implement_this_trait() {}
+                type Tag = ();
+                type ProjectToTag = ::zerocopy::pointer::cast::CastToUnit;
+            }
+        };
+        #[allow(
+            deprecated,
+            private_bounds,
+            non_local_definitions,
+            non_camel_case_types,
+            non_upper_case_globals,
+            non_snake_case,
+            non_ascii_idents,
+            clippy::missing_inline_in_public_items,
+        )]
+        #[deny(ambiguous_associated_items)]
+        #[automatically_derived]
+        const _: () = {
+            unsafe impl ::zerocopy::HasField<
+                ẕa,
+                { ::zerocopy::UNION_VARIANT_ID },
+                { ::zerocopy::ident_id!(a) },
+            > for Foo {
+                fn only_derive_is_allowed_to_implement_this_trait() {}
+                type Type = u8;
+                #[inline(always)]
+                fn project(
+                    slf: ::zerocopy::pointer::PtrInner<'_, Self>,
+                ) -> *mut <Self as ::zerocopy::HasField<
+                    ẕa,
+                    { ::zerocopy::UNION_VARIANT_ID },
+                    { ::zerocopy::ident_id!(a) },
+                >>::Type {
+                    let slf = slf.as_ptr();
+                    unsafe {
+                        ::zerocopy::util::macro_util::core_reexport::ptr::addr_of_mut!(
+                            (* slf).a
+                        )
+                    }
+                }
+            }
+        };
+    };
+};
+#[allow(
+    deprecated,
+    private_bounds,
+    non_local_definitions,
+    non_camel_case_types,
+    non_upper_case_globals,
+    non_snake_case,
+    non_ascii_idents,
+    clippy::missing_inline_in_public_items,
+)]
+#[deny(ambiguous_associated_items)]
+#[automatically_derived]
+const _: () = {
+    unsafe impl ::zerocopy::FromZeros for Foo
+    where
+        u8: ::zerocopy::FromZeros,
+    {
+        fn only_derive_is_allowed_to_implement_this_trait() {}
+    }
+};
+#[allow(
+    deprecated,
+    private_bounds,
+    non_local_definitions,
+    non_camel_case_types,
+    non_upper_case_globals,
+    non_snake_case,
+    non_ascii_idents,
+    clippy::missing_inline_in_public_items,
+)]
+#[deny(ambiguous_associated_items)]
+#[automatically_derived]
+const _: () = {
+    unsafe impl ::zerocopy::FromBytes for Foo
+    where
+        u8: ::zerocopy::FromBytes,
+    {
+        fn only_derive_is_allowed_to_implement_this_trait() {}
+    }
+};

data/rust-vendor/zerocopy-derive/src/output_tests/expected/from_zeros.expected.rs

@@ -0,0 +1,39 @@
+#[allow(
+    deprecated,
+    private_bounds,
+    non_local_definitions,
+    non_camel_case_types,
+    non_upper_case_globals,
+    non_snake_case,
+    non_ascii_idents,
+    clippy::missing_inline_in_public_items,
+)]
+#[deny(ambiguous_associated_items)]
+#[automatically_derived]
+const _: () = {
+    unsafe impl ::zerocopy::TryFromBytes for Foo {
+        fn only_derive_is_allowed_to_implement_this_trait() {}
+        fn is_bit_valid(
+            mut candidate: ::zerocopy::Maybe<Self>,
+        ) -> ::zerocopy::util::macro_util::core_reexport::primitive::bool {
+            true
+        }
+    }
+};
+#[allow(
+    deprecated,
+    private_bounds,
+    non_local_definitions,
+    non_camel_case_types,
+    non_upper_case_globals,
+    non_snake_case,
+    non_ascii_idents,
+    clippy::missing_inline_in_public_items,
+)]
+#[deny(ambiguous_associated_items)]
+#[automatically_derived]
+const _: () = {
+    unsafe impl ::zerocopy::FromZeros for Foo {
+        fn only_derive_is_allowed_to_implement_this_trait() {}
+    }
+};

data/rust-vendor/zerocopy-derive/src/output_tests/expected/hash.expected.rs

@@ -0,0 +1,24 @@
+impl<T: Clone> ::zerocopy::util::macro_util::core_reexport::hash::Hash for Foo<T>
+where
+    Self: ::zerocopy::IntoBytes + ::zerocopy::Immutable,
+    Self: Sized,
+{
+    fn hash<H: ::zerocopy::util::macro_util::core_reexport::hash::Hasher>(
+        &self,
+        state: &mut H,
+    ) {
+        ::zerocopy::util::macro_util::core_reexport::hash::Hasher::write(
+            state,
+            ::zerocopy::IntoBytes::as_bytes(self),
+        )
+    }
+    fn hash_slice<H: ::zerocopy::util::macro_util::core_reexport::hash::Hasher>(
+        data: &[Self],
+        state: &mut H,
+    ) {
+        ::zerocopy::util::macro_util::core_reexport::hash::Hasher::write(
+            state,
+            ::zerocopy::IntoBytes::as_bytes(data),
+        )
+    }
+}

data/rust-vendor/zerocopy-derive/src/output_tests/expected/immutable.expected.rs

@@ -0,0 +1,17 @@
+#[allow(
+    deprecated,
+    private_bounds,
+    non_local_definitions,
+    non_camel_case_types,
+    non_upper_case_globals,
+    non_snake_case,
+    non_ascii_idents,
+    clippy::missing_inline_in_public_items,
+)]
+#[deny(ambiguous_associated_items)]
+#[automatically_derived]
+const _: () = {
+    unsafe impl ::zerocopy::Immutable for Foo {
+        fn only_derive_is_allowed_to_implement_this_trait() {}
+    }
+};

data/rust-vendor/zerocopy-derive/src/output_tests/expected/into_bytes_enum.expected.rs

@@ -0,0 +1,17 @@
+#[allow(
+    deprecated,
+    private_bounds,
+    non_local_definitions,
+    non_camel_case_types,
+    non_upper_case_globals,
+    non_snake_case,
+    non_ascii_idents,
+    clippy::missing_inline_in_public_items,
+)]
+#[deny(ambiguous_associated_items)]
+#[automatically_derived]
+const _: () = {
+    unsafe impl ::zerocopy::IntoBytes for Foo {
+        fn only_derive_is_allowed_to_implement_this_trait() {}
+    }
+};

data/rust-vendor/zerocopy-derive/src/output_tests/expected/into_bytes_struct_basic.expected.rs

@@ -0,0 +1,25 @@
+#[allow(
+    deprecated,
+    private_bounds,
+    non_local_definitions,
+    non_camel_case_types,
+    non_upper_case_globals,
+    non_snake_case,
+    non_ascii_idents,
+    clippy::missing_inline_in_public_items,
+)]
+#[deny(ambiguous_associated_items)]
+#[automatically_derived]
+const _: () = {
+    unsafe impl ::zerocopy::IntoBytes for Foo
+    where
+        u8: ::zerocopy::IntoBytes,
+        u8: ::zerocopy::IntoBytes,
+        (): ::zerocopy::util::macro_util::PaddingFree<
+            Self,
+            { ::zerocopy::struct_padding!(Self, [(u8), (u8)]) },
+        >,
+    {
+        fn only_derive_is_allowed_to_implement_this_trait() {}
+    }
+};

data/rust-vendor/zerocopy-derive/src/output_tests/expected/into_bytes_struct_empty.expected.rs

@@ -0,0 +1,17 @@
+#[allow(
+    deprecated,
+    private_bounds,
+    non_local_definitions,
+    non_camel_case_types,
+    non_upper_case_globals,
+    non_snake_case,
+    non_ascii_idents,
+    clippy::missing_inline_in_public_items,
+)]
+#[deny(ambiguous_associated_items)]
+#[automatically_derived]
+const _: () = {
+    unsafe impl ::zerocopy::IntoBytes for Foo {
+        fn only_derive_is_allowed_to_implement_this_trait() {}
+    }
+};

data/rust-vendor/zerocopy-derive/src/output_tests/expected/into_bytes_struct_trailing.expected.rs

@@ -0,0 +1,25 @@
+#[allow(
+    deprecated,
+    private_bounds,
+    non_local_definitions,
+    non_camel_case_types,
+    non_upper_case_globals,
+    non_snake_case,
+    non_ascii_idents,
+    clippy::missing_inline_in_public_items,
+)]
+#[deny(ambiguous_associated_items)]
+#[automatically_derived]
+const _: () = {
+    unsafe impl ::zerocopy::IntoBytes for Foo
+    where
+        u8: ::zerocopy::IntoBytes,
+        [Trailing]: ::zerocopy::IntoBytes,
+        (): ::zerocopy::util::macro_util::DynamicPaddingFree<
+            Self,
+            { ::zerocopy::repr_c_struct_has_padding!(Self, [(u8), ([Trailing])]) },
+        >,
+    {
+        fn only_derive_is_allowed_to_implement_this_trait() {}
+    }
+};

data/rust-vendor/zerocopy-derive/src/output_tests/expected/into_bytes_struct_trailing_generic.expected.rs

@@ -0,0 +1,21 @@
+#[allow(
+    deprecated,
+    private_bounds,
+    non_local_definitions,
+    non_camel_case_types,
+    non_upper_case_globals,
+    non_snake_case,
+    non_ascii_idents,
+    clippy::missing_inline_in_public_items,
+)]
+#[deny(ambiguous_associated_items)]
+#[automatically_derived]
+const _: () = {
+    unsafe impl<Trailing> ::zerocopy::IntoBytes for Foo<Trailing>
+    where
+        u8: ::zerocopy::IntoBytes + ::zerocopy::Unaligned,
+        [Trailing]: ::zerocopy::IntoBytes + ::zerocopy::Unaligned,
+    {
+        fn only_derive_is_allowed_to_implement_this_trait() {}
+    }
+};

data/rust-vendor/zerocopy-derive/src/output_tests/expected/known_layout_repr_c_struct.expected.rs

@@ -0,0 +1,135 @@
+#[allow(
+    deprecated,
+    private_bounds,
+    non_local_definitions,
+    non_camel_case_types,
+    non_upper_case_globals,
+    non_snake_case,
+    non_ascii_idents,
+    clippy::missing_inline_in_public_items,
+)]
+#[deny(ambiguous_associated_items)]
+#[automatically_derived]
+const _: () = {
+    unsafe impl<T, U> ::zerocopy::KnownLayout for Foo<T, U>
+    where
+        U: ::zerocopy::KnownLayout,
+    {
+        fn only_derive_is_allowed_to_implement_this_trait() {}
+        type PointerMetadata = <U as ::zerocopy::KnownLayout>::PointerMetadata;
+        type MaybeUninit = __ZerocopyKnownLayoutMaybeUninit<T, U>;
+        const LAYOUT: ::zerocopy::DstLayout = ::zerocopy::DstLayout::for_repr_c_struct(
+            ::zerocopy::util::macro_util::core_reexport::num::NonZeroUsize::new(
+                2u32 as usize,
+            ),
+            ::zerocopy::util::macro_util::core_reexport::option::Option::None,
+            &[
+                ::zerocopy::DstLayout::for_type::<T>(),
+                <U as ::zerocopy::KnownLayout>::LAYOUT,
+            ],
+        );
+        #[inline(always)]
+        fn raw_from_ptr_len(
+            bytes: ::zerocopy::util::macro_util::core_reexport::ptr::NonNull<u8>,
+            meta: <Self as ::zerocopy::KnownLayout>::PointerMetadata,
+        ) -> ::zerocopy::util::macro_util::core_reexport::ptr::NonNull<Self> {
+            let trailing = <U as ::zerocopy::KnownLayout>::raw_from_ptr_len(bytes, meta);
+            let slf = trailing.as_ptr() as *mut Self;
+            unsafe {
+                ::zerocopy::util::macro_util::core_reexport::ptr::NonNull::new_unchecked(
+                    slf,
+                )
+            }
+        }
+        #[inline(always)]
+        fn pointer_to_metadata(
+            ptr: *mut Self,
+        ) -> <Self as ::zerocopy::KnownLayout>::PointerMetadata {
+            <U>::pointer_to_metadata(ptr as *mut _)
+        }
+    }
+    struct __Zerocopy_Field_0;
+    struct __Zerocopy_Field_1;
+    unsafe impl<T, U> ::zerocopy::util::macro_util::Field<__Zerocopy_Field_0>
+    for Foo<T, U> {
+        type Type = T;
+    }
+    unsafe impl<T, U> ::zerocopy::util::macro_util::Field<__Zerocopy_Field_1>
+    for Foo<T, U> {
+        type Type = U;
+    }
+    #[repr(C)]
+    #[repr(align(2))]
+    #[doc(hidden)]
+    struct __ZerocopyKnownLayoutMaybeUninit<T, U>(
+        ::zerocopy::util::macro_util::core_reexport::mem::MaybeUninit<
+            <Foo<T, U> as ::zerocopy::util::macro_util::Field<__Zerocopy_Field_0>>::Type,
+        >,
+        ::zerocopy::util::macro_util::core_reexport::mem::ManuallyDrop<
+            <<Foo<
+                T,
+                U,
+            > as ::zerocopy::util::macro_util::Field<
+                __Zerocopy_Field_1,
+            >>::Type as ::zerocopy::KnownLayout>::MaybeUninit,
+        >,
+    )
+    where
+        <Foo<
+            T,
+            U,
+        > as ::zerocopy::util::macro_util::Field<
+            __Zerocopy_Field_1,
+        >>::Type: ::zerocopy::KnownLayout;
+    unsafe impl<T, U> ::zerocopy::KnownLayout for __ZerocopyKnownLayoutMaybeUninit<T, U>
+    where
+        <Foo<
+            T,
+            U,
+        > as ::zerocopy::util::macro_util::Field<
+            __Zerocopy_Field_1,
+        >>::Type: ::zerocopy::KnownLayout,
+    {
+        fn only_derive_is_allowed_to_implement_this_trait() {}
+        type PointerMetadata = <Foo<T, U> as ::zerocopy::KnownLayout>::PointerMetadata;
+        type MaybeUninit = Self;
+        const LAYOUT: ::zerocopy::DstLayout = <Foo<
+            T,
+            U,
+        > as ::zerocopy::KnownLayout>::LAYOUT;
+        #[inline(always)]
+        fn raw_from_ptr_len(
+            bytes: ::zerocopy::util::macro_util::core_reexport::ptr::NonNull<u8>,
+            meta: <Self as ::zerocopy::KnownLayout>::PointerMetadata,
+        ) -> ::zerocopy::util::macro_util::core_reexport::ptr::NonNull<Self> {
+            let trailing = <<<Foo<
+                T,
+                U,
+            > as ::zerocopy::util::macro_util::Field<
+                __Zerocopy_Field_1,
+            >>::Type as ::zerocopy::KnownLayout>::MaybeUninit as ::zerocopy::KnownLayout>::raw_from_ptr_len(
+                bytes,
+                meta,
+            );
+            let slf = trailing.as_ptr() as *mut Self;
+            unsafe {
+                ::zerocopy::util::macro_util::core_reexport::ptr::NonNull::new_unchecked(
+                    slf,
+                )
+            }
+        }
+        #[inline(always)]
+        fn pointer_to_metadata(
+            ptr: *mut Self,
+        ) -> <Self as ::zerocopy::KnownLayout>::PointerMetadata {
+            <<<Foo<
+                T,
+                U,
+            > as ::zerocopy::util::macro_util::Field<
+                __Zerocopy_Field_1,
+            >>::Type as ::zerocopy::KnownLayout>::MaybeUninit>::pointer_to_metadata(
+                ptr as *mut _,
+            )
+        }
+    }
+};

data/rust-vendor/zerocopy-derive/src/output_tests/expected/known_layout_struct.expected.rs

@@ -0,0 +1,34 @@
+#[allow(
+    deprecated,
+    private_bounds,
+    non_local_definitions,
+    non_camel_case_types,
+    non_upper_case_globals,
+    non_snake_case,
+    non_ascii_idents,
+    clippy::missing_inline_in_public_items,
+)]
+#[deny(ambiguous_associated_items)]
+#[automatically_derived]
+const _: () = {
+    unsafe impl ::zerocopy::KnownLayout for Foo
+    where
+        Self: ::zerocopy::util::macro_util::core_reexport::marker::Sized,
+    {
+        fn only_derive_is_allowed_to_implement_this_trait() {}
+        type PointerMetadata = ();
+        type MaybeUninit = ::zerocopy::util::macro_util::core_reexport::mem::MaybeUninit<
+            Self,
+        >;
+        const LAYOUT: ::zerocopy::DstLayout = ::zerocopy::DstLayout::for_type::<Self>();
+        #[inline(always)]
+        fn raw_from_ptr_len(
+            bytes: ::zerocopy::util::macro_util::core_reexport::ptr::NonNull<u8>,
+            _meta: (),
+        ) -> ::zerocopy::util::macro_util::core_reexport::ptr::NonNull<Self> {
+            bytes.cast::<Self>()
+        }
+        #[inline(always)]
+        fn pointer_to_metadata(_ptr: *mut Self) -> () {}
+    }
+};

data/rust-vendor/zerocopy-derive/src/output_tests/expected/split_at_repr_c.expected.rs

@@ -0,0 +1,22 @@
+#[allow(
+    deprecated,
+    private_bounds,
+    non_local_definitions,
+    non_camel_case_types,
+    non_upper_case_globals,
+    non_snake_case,
+    non_ascii_idents,
+    clippy::missing_inline_in_public_items,
+)]
+#[deny(ambiguous_associated_items)]
+#[automatically_derived]
+const _: () = {
+    unsafe impl<T: ?Sized + Copy> ::zerocopy::SplitAt for Foo<T>
+    where
+        Self: Copy,
+        T: ::zerocopy::SplitAt,
+    {
+        fn only_derive_is_allowed_to_implement_this_trait() {}
+        type Elem = <T as ::zerocopy::SplitAt>::Elem;
+    }
+};