DeCarabas/oden
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Vendor things

Browse source
This commit is contained in:
John Doty 2024-03-08 11:03:01 -08:00
parent 5deceec006
commit 977e3c17e5
19434 changed files with 10682014 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

92
third-party/vendor/memoffset/src/lib.rs vendored Normal file
View file

@ -0,0 +1,92 @@
// Copyright (c) 2017 Gilad Naaman
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//! A crate used for calculating offsets of struct members and their spans.
//!
//! This functionality currently can not be used in compile time code such as `const` or `const fn` definitions.
//!
//! ## Examples
//! ```
//! use memoffset::{offset_of, span_of};
//!
//! #[repr(C, packed)]
//! struct HelpMeIAmTrappedInAStructFactory {
//! help_me_before_they_: [u8; 15],
//! a: u32
//! }
//!
//! fn main() {
//! assert_eq!(offset_of!(HelpMeIAmTrappedInAStructFactory, a), 15);
//! assert_eq!(span_of!(HelpMeIAmTrappedInAStructFactory, a), 15..19);
//! assert_eq!(span_of!(HelpMeIAmTrappedInAStructFactory, help_me_before_they_ .. a), 0..15);
//! }
//! ```
//!
//! This functionality can be useful, for example, for checksum calculations:
//!
//! ```ignore
//! #[repr(C, packed)]
//! struct Message {
//! header: MessageHeader,
//! fragment_index: u32,
//! fragment_count: u32,
//! payload: [u8; 1024],
//! checksum: u16
//! }
//!
//! let checksum_range = &raw[span_of!(Message, header..checksum)];
//! let checksum = crc16(checksum_range);
//! ```
#![no_std]
#![cfg_attr(
feature = "unstable_const",
feature(const_ptr_offset_from, const_refs_to_cell)
)]
#[macro_use]
#[cfg(doctests)]
#[cfg(doctest)]
extern crate doc_comment;
#[cfg(doctests)]
#[cfg(doctest)]
doctest!("../README.md");
/// Hidden module for things the macros need to access.
#[doc(hidden)]
pub mod __priv {
#[doc(hidden)]
pub use core::mem;
#[doc(hidden)]
pub use core::ptr;
/// Use type inference to obtain the size of the pointee (without actually using the pointer).
#[doc(hidden)]
pub fn size_of_pointee<T>(_ptr: *const T) -> usize {
mem::size_of::<T>()
}
}
#[macro_use]
mod raw_field;
#[macro_use]
mod offset_of;
#[macro_use]
mod span_of;

282
third-party/vendor/memoffset/src/offset_of.rs vendored Normal file
View file

@ -0,0 +1,282 @@
// Copyright (c) 2017 Gilad Naaman
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
/// Macro to create a local `base_ptr` raw pointer of the given type, avoiding UB as
/// much as is possible currently.
#[cfg(maybe_uninit)]
#[macro_export]
#[doc(hidden)]
macro_rules! _memoffset__let_base_ptr {
($name:ident, $type:ty) => {
// No UB here, and the pointer does not dangle, either.
// But we have to make sure that `uninit` lives long enough,
// so it has to be in the same scope as `$name`. That's why
// `let_base_ptr` declares a variable (several, actually)
// instead of returning one.
let uninit = $crate::__priv::mem::MaybeUninit::<$type>::uninit();
let $name: *const $type = uninit.as_ptr();
};
}
#[cfg(not(maybe_uninit))]
#[macro_export]
#[doc(hidden)]
macro_rules! _memoffset__let_base_ptr {
($name:ident, $type:ty) => {
// No UB right here, but we will later dereference this pointer to
// offset into a field, and that is UB because the pointer is dangling.
let $name = $crate::__priv::mem::align_of::<$type>() as *const $type;
};
}
/// Macro to compute the distance between two pointers.
#[cfg(feature = "unstable_const")]
#[macro_export]
#[doc(hidden)]
macro_rules! _memoffset_offset_from_unsafe {
($field:expr, $base:expr) => {{
let field = $field; // evaluate $field outside the `unsafe` block
let base = $base; // evaluate $base outside the `unsafe` block
// Compute offset, with unstable `offset_from` for const-compatibility.
// (Requires the pointers to not dangle, but we already need that for `raw_field!` anyway.)
unsafe { (field as *const u8).offset_from(base as *const u8) as usize }
}};
}
#[cfg(not(feature = "unstable_const"))]
#[macro_export]
#[doc(hidden)]
macro_rules! _memoffset_offset_from_unsafe {
($field:expr, $base:expr) => {
// Compute offset.
($field as usize) - ($base as usize)
};
}
/// Calculates the offset of the specified field from the start of the named struct.
///
/// ## Examples
/// ```
/// use memoffset::offset_of;
///
/// #[repr(C, packed)]
/// struct Foo {
/// a: u32,
/// b: u64,
/// c: [u8; 5]
/// }
///
/// fn main() {
/// assert_eq!(offset_of!(Foo, a), 0);
/// assert_eq!(offset_of!(Foo, b), 4);
/// }
/// ```
#[macro_export(local_inner_macros)]
macro_rules! offset_of {
($parent:path, $field:tt) => {{
// Get a base pointer (non-dangling if rustc supports `MaybeUninit`).
_memoffset__let_base_ptr!(base_ptr, $parent);
// Get field pointer.
let field_ptr = raw_field!(base_ptr, $parent, $field);
// Compute offset.
_memoffset_offset_from_unsafe!(field_ptr, base_ptr)
}};
}
/// Calculates the offset of the specified field from the start of the tuple.
///
/// ## Examples
/// ```
/// use memoffset::offset_of_tuple;
///
/// fn main() {
/// assert!(offset_of_tuple!((u8, u32), 1) >= 0, "Tuples do not have a defined layout");
/// }
/// ```
#[cfg(tuple_ty)]
#[macro_export(local_inner_macros)]
macro_rules! offset_of_tuple {
($parent:ty, $field:tt) => {{
// Get a base pointer (non-dangling if rustc supports `MaybeUninit`).
_memoffset__let_base_ptr!(base_ptr, $parent);
// Get field pointer.
let field_ptr = raw_field_tuple!(base_ptr, $parent, $field);
// Compute offset.
_memoffset_offset_from_unsafe!(field_ptr, base_ptr)
}};
}
#[cfg(test)]
mod tests {
#[test]
fn offset_simple() {
#[repr(C)]
struct Foo {
a: u32,
b: [u8; 2],
c: i64,
}
assert_eq!(offset_of!(Foo, a), 0);
assert_eq!(offset_of!(Foo, b), 4);
assert_eq!(offset_of!(Foo, c), 8);
}
#[test]
#[cfg_attr(miri, ignore)] // this creates unaligned references
fn offset_simple_packed() {
#[repr(C, packed)]
struct Foo {
a: u32,
b: [u8; 2],
c: i64,
}
assert_eq!(offset_of!(Foo, a), 0);
assert_eq!(offset_of!(Foo, b), 4);
assert_eq!(offset_of!(Foo, c), 6);
}
#[test]
fn tuple_struct() {
#[repr(C)]
struct Tup(i32, i32);
assert_eq!(offset_of!(Tup, 0), 0);
assert_eq!(offset_of!(Tup, 1), 4);
}
#[test]
fn path() {
mod sub {
#[repr(C)]
pub struct Foo {
pub x: u32,
}
}
assert_eq!(offset_of!(sub::Foo, x), 0);
}
#[test]
fn inside_generic_method() {
struct Pair<T, U>(T, U);
fn foo<T, U>(_: Pair<T, U>) -> usize {
offset_of!(Pair<T, U>, 1)
}
assert_eq!(foo(Pair(0, 0)), 4);
}
#[cfg(tuple_ty)]
#[test]
fn test_tuple_offset() {
let f = (0i32, 0.0f32, 0u8);
let f_ptr = &f as *const _;
let f1_ptr = &f.1 as *const _;
assert_eq!(
f1_ptr as usize - f_ptr as usize,
offset_of_tuple!((i32, f32, u8), 1)
);
}
#[test]
fn test_raw_field() {
#[repr(C)]
struct Foo {
a: u32,
b: [u8; 2],
c: i64,
}
let f: Foo = Foo {
a: 0,
b: [0, 0],
c: 0,
};
let f_ptr = &f as *const _;
assert_eq!(f_ptr as usize + 0, raw_field!(f_ptr, Foo, a) as usize);
assert_eq!(f_ptr as usize + 4, raw_field!(f_ptr, Foo, b) as usize);
assert_eq!(f_ptr as usize + 8, raw_field!(f_ptr, Foo, c) as usize);
}
#[cfg(tuple_ty)]
#[test]
fn test_raw_field_tuple() {
let t = (0u32, 0u8, false);
let t_ptr = &t as *const _;
let t_addr = t_ptr as usize;
assert_eq!(
&t.0 as *const _ as usize - t_addr,
raw_field_tuple!(t_ptr, (u32, u8, bool), 0) as usize - t_addr
);
assert_eq!(
&t.1 as *const _ as usize - t_addr,
raw_field_tuple!(t_ptr, (u32, u8, bool), 1) as usize - t_addr
);
assert_eq!(
&t.2 as *const _ as usize - t_addr,
raw_field_tuple!(t_ptr, (u32, u8, bool), 2) as usize - t_addr
);
}
#[cfg(feature = "unstable_const")]
#[test]
fn const_offset() {
#[repr(C)]
struct Foo {
a: u32,
b: [u8; 2],
c: i64,
}
assert_eq!([0; offset_of!(Foo, b)].len(), 4);
}
#[cfg(feature = "unstable_const")]
#[test]
fn const_offset_interior_mutable() {
#[repr(C)]
struct Foo {
a: u32,
b: core::cell::Cell<u32>,
}
assert_eq!([0; offset_of!(Foo, b)].len(), 4);
}
#[cfg(feature = "unstable_const")]
#[test]
fn const_fn_offset() {
const fn test_fn() -> usize {
#[repr(C)]
struct Foo {
a: u32,
b: [u8; 2],
c: i64,
}
offset_of!(Foo, b)
}
assert_eq!([0; test_fn()].len(), 4);
}
}

117
third-party/vendor/memoffset/src/raw_field.rs vendored Normal file
View file

@ -0,0 +1,117 @@
// Copyright (c) 2020 Gilad Naaman, Ralf Jung
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
/// `addr_of!`, or just ref-then-cast when that is not available.
#[cfg(raw_ref_macros)]
#[macro_export]
#[doc(hidden)]
macro_rules! _memoffset__addr_of {
($path:expr) => {{
$crate::__priv::ptr::addr_of!($path)
}};
}
#[cfg(not(raw_ref_macros))]
#[macro_export]
#[doc(hidden)]
macro_rules! _memoffset__addr_of {
($path:expr) => {{
// This is UB because we create an intermediate reference to uninitialized memory.
// Nothing we can do about that without `addr_of!` though.
&$path as *const _
}};
}
/// Deref-coercion protection macro.
#[cfg(allow_clippy)]
#[macro_export]
#[doc(hidden)]
macro_rules! _memoffset__field_check {
($type:path, $field:tt) => {
// Make sure the field actually exists. This line ensures that a
// compile-time error is generated if $field is accessed through a
// Deref impl.
#[allow(clippy::unneeded_field_pattern)]
let $type { $field: _, .. };
};
}
#[cfg(not(allow_clippy))]
#[macro_export]
#[doc(hidden)]
macro_rules! _memoffset__field_check {
($type:path, $field:tt) => {
// Make sure the field actually exists. This line ensures that a
// compile-time error is generated if $field is accessed through a
// Deref impl.
let $type { $field: _, .. };
};
}
/// Deref-coercion protection macro.
#[macro_export]
#[doc(hidden)]
macro_rules! _memoffset__field_check_tuple {
($type:ty, $field:tt) => {
// Make sure the type argument is a tuple
let (_, ..): $type;
};
}
/// Computes a const raw pointer to the given field of the given base pointer
/// to the given parent type.
///
/// The `base` pointer *must not* be dangling, but it *may* point to
/// uninitialized memory.
#[macro_export(local_inner_macros)]
macro_rules! raw_field {
($base:expr, $parent:path, $field:tt) => {{
_memoffset__field_check!($parent, $field);
let base = $base; // evaluate $base outside the `unsafe` block
// Get the field address.
// Crucially, we know that this will not trigger a deref coercion because
// of the field check we did above.
#[allow(unused_unsafe)] // for when the macro is used in an unsafe block
unsafe {
_memoffset__addr_of!((*(base as *const $parent)).$field)
}
}};
}
/// Computes a const raw pointer to the given field of the given base pointer
/// to the given parent tuple typle.
///
/// The `base` pointer *must not* be dangling, but it *may* point to
/// uninitialized memory.
#[cfg(tuple_ty)]
#[macro_export(local_inner_macros)]
macro_rules! raw_field_tuple {
($base:expr, $parent:ty, $field:tt) => {{
_memoffset__field_check_tuple!($parent, $field);
let base = $base; // evaluate $base outside the `unsafe` block
// Get the field address.
// Crucially, we know that this will not trigger a deref coercion because
// of the field check we did above.
#[allow(unused_unsafe)] // for when the macro is used in an unsafe block
unsafe {
_memoffset__addr_of!((*(base as *const $parent)).$field)
}
}};
}

256
third-party/vendor/memoffset/src/span_of.rs vendored Normal file
View file

@ -0,0 +1,256 @@
// Copyright (c) 2017 Gilad Naaman
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
/// Reexport for `local_inner_macros`; see
/// <https://doc.rust-lang.org/edition-guide/rust-2018/macros/macro-changes.html#macros-using-local_inner_macros>.
#[doc(hidden)]
#[macro_export]
macro_rules! _memoffset__compile_error {
($($inner:tt)*) => {
compile_error! { $($inner)* }
}
}
/// Produces a range instance representing the sub-slice containing the specified member.
///
/// This macro provides 2 forms of differing functionalities.
///
/// The first form is identical to the appearance of the `offset_of!` macro.
///
/// ```ignore
/// span_of!(Struct, member)
/// ```
///
/// The second form of `span_of!` returns a sub-slice which starts at one field, and ends at another.
/// The general pattern of this form is:
///
/// ```ignore
/// // Exclusive
/// span_of!(Struct, member_a .. member_b)
/// // Inclusive
/// span_of!(Struct, member_a ..= member_b)
///
/// // Open-ended ranges
/// span_of!(Struct, .. end)
/// span_of!(Struct, start ..)
/// ```
///
/// *Note*:
/// This macro uses recursion in order to resolve the range expressions, so there is a limit to
/// the complexity of the expression.
/// In order to raise the limit, the compiler's recursion limit should be lifted.
///
/// ## Examples
/// ```
/// use memoffset::span_of;
///
/// #[repr(C)]
/// struct Florp {
/// a: u32
/// }
///
/// #[repr(C)]
/// struct Blarg {
/// x: [u32; 2],
/// y: [u8; 56],
/// z: Florp,
/// egg: [[u8; 4]; 4]
/// }
///
/// fn main() {
/// assert_eq!(0..84, span_of!(Blarg, ..));
/// assert_eq!(0..8, span_of!(Blarg, .. y));
/// assert_eq!(0..64, span_of!(Blarg, ..= y));
/// assert_eq!(0..8, span_of!(Blarg, x));
/// assert_eq!(8..84, span_of!(Blarg, y ..));
/// assert_eq!(0..8, span_of!(Blarg, x .. y));
/// assert_eq!(0..64, span_of!(Blarg, x ..= y));
/// }
/// ```
#[macro_export(local_inner_macros)]
macro_rules! span_of {
(@helper $root:ident, [] ..=) => {
_memoffset__compile_error!("Expected a range, found '..='")
};
(@helper $root:ident, [] ..) => {
_memoffset__compile_error!("Expected a range, found '..'")
};
// No explicit begin for range.
(@helper $root:ident, $parent:path, [] ..) => {{
($root as usize,
$root as usize + $crate::__priv::size_of_pointee($root))
}};
(@helper $root:ident, $parent:path, [] ..= $end:tt) => {{
let end = raw_field!($root, $parent, $end);
($root as usize, end as usize + $crate::__priv::size_of_pointee(end))
}};
(@helper $root:ident, $parent:path, [] .. $end:tt) => {{
($root as usize, raw_field!($root, $parent, $end) as usize)
}};
// Explicit begin and end for range.
(@helper $root:ident, $parent:path, # $begin:tt [] ..= $end:tt) => {{
let begin = raw_field!($root, $parent, $begin);
let end = raw_field!($root, $parent, $end);
(begin as usize, end as usize + $crate::__priv::size_of_pointee(end))
}};
(@helper $root:ident, $parent:path, # $begin:tt [] .. $end:tt) => {{
(raw_field!($root, $parent, $begin) as usize,
raw_field!($root, $parent, $end) as usize)
}};
// No explicit end for range.
(@helper $root:ident, $parent:path, # $begin:tt [] ..) => {{
(raw_field!($root, $parent, $begin) as usize,
$root as usize + $crate::__priv::size_of_pointee($root))
}};
(@helper $root:ident, $parent:path, # $begin:tt [] ..=) => {{
_memoffset__compile_error!(
"Found inclusive range to the end of a struct. Did you mean '..' instead of '..='?")
}};
// Just one field.
(@helper $root:ident, $parent:path, # $field:tt []) => {{
let field = raw_field!($root, $parent, $field);
(field as usize, field as usize + $crate::__priv::size_of_pointee(field))
}};
// Parsing.
(@helper $root:ident, $parent:path, $(# $begin:tt)+ [] $tt:tt $($rest:tt)*) => {{
span_of!(@helper $root, $parent, $(#$begin)* #$tt [] $($rest)*)
}};
(@helper $root:ident, $parent:path, [] $tt:tt $($rest:tt)*) => {{
span_of!(@helper $root, $parent, #$tt [] $($rest)*)
}};
// Entry point.
($sty:path, $($exp:tt)+) => ({
// Get a base pointer.
_memoffset__let_base_ptr!(root, $sty);
let base = root as usize;
let (begin, end) = span_of!(@helper root, $sty, [] $($exp)*);
begin-base..end-base
});
}
#[cfg(test)]
mod tests {
use core::mem;
#[test]
fn span_simple() {
#[repr(C)]
struct Foo {
a: u32,
b: [u8; 2],
c: i64,
}
assert_eq!(span_of!(Foo, a), 0..4);
assert_eq!(span_of!(Foo, b), 4..6);
assert_eq!(span_of!(Foo, c), 8..8 + 8);
}
#[test]
#[cfg_attr(miri, ignore)] // this creates unaligned references
fn span_simple_packed() {
#[repr(C, packed)]
struct Foo {
a: u32,
b: [u8; 2],
c: i64,
}
assert_eq!(span_of!(Foo, a), 0..4);
assert_eq!(span_of!(Foo, b), 4..6);
assert_eq!(span_of!(Foo, c), 6..6 + 8);
}
#[test]
fn span_forms() {
#[repr(C)]
struct Florp {
a: u32,
}
#[repr(C)]
struct Blarg {
x: u64,
y: [u8; 56],
z: Florp,
egg: [[u8; 4]; 5],
}
// Love me some brute force
assert_eq!(0..8, span_of!(Blarg, x));
assert_eq!(64..68, span_of!(Blarg, z));
assert_eq!(68..mem::size_of::<Blarg>(), span_of!(Blarg, egg));
assert_eq!(8..64, span_of!(Blarg, y..z));
assert_eq!(0..64, span_of!(Blarg, x..=y));
}
#[test]
fn ig_test() {
#[repr(C)]
struct Member {
foo: u32,
}
#[repr(C)]
struct Test {
x: u64,
y: [u8; 56],
z: Member,
egg: [[u8; 4]; 4],
}
assert_eq!(span_of!(Test, ..x), 0..0);
assert_eq!(span_of!(Test, ..=x), 0..8);
assert_eq!(span_of!(Test, ..y), 0..8);
assert_eq!(span_of!(Test, ..=y), 0..64);
assert_eq!(span_of!(Test, ..z), 0..64);
assert_eq!(span_of!(Test, ..=z), 0..68);
assert_eq!(span_of!(Test, ..egg), 0..68);
assert_eq!(span_of!(Test, ..=egg), 0..84);
assert_eq!(span_of!(Test, ..), 0..mem::size_of::<Test>());
assert_eq!(
span_of!(Test, x..),
offset_of!(Test, x)..mem::size_of::<Test>()
);
assert_eq!(
span_of!(Test, y..),
offset_of!(Test, y)..mem::size_of::<Test>()
);
assert_eq!(
span_of!(Test, z..),
offset_of!(Test, z)..mem::size_of::<Test>()
);
assert_eq!(
span_of!(Test, egg..),
offset_of!(Test, egg)..mem::size_of::<Test>()
);
assert_eq!(
span_of!(Test, x..y),
offset_of!(Test, x)..offset_of!(Test, y)
);
assert_eq!(
span_of!(Test, x..=y),
offset_of!(Test, x)..offset_of!(Test, y) + mem::size_of::<[u8; 56]>()
);
}
}