#![feature(prelude_import)]
#![feature(rustc_attrs)]
#[prelude_import]
use std::prelude::rust_2021::*;
#[macro_use]
extern crate std;
use std::{mem::ManuallyDrop, ptr::NonNull, marker::PhantomData, ops::{Deref, DerefMut}};
use bytecheck::CheckBytes;
use rkyv::{
Archive, Deserialize, Serialize, Archived, Resolver, ArchiveUnsized,
boxed::ArchivedBox, SerializeUnsized,
};
use trace::trace;
const DEPTH: ::std::thread::LocalKey<::std::cell::Cell<usize>> = {
#[inline]
fn __init() -> ::std::cell::Cell<usize> {
::std::cell::Cell::new(0)
}
#[inline]
unsafe fn __getit(
init: ::std::option::Option<&mut ::std::option::Option<::std::cell::Cell<usize>>>,
) -> ::std::option::Option<&'static ::std::cell::Cell<usize>> {
#[thread_local]
#[cfg(
all(
target_thread_local,
not(all(target_family = "wasm", not(target_feature = "atomics"))),
)
)]
static __KEY: ::std::thread::__FastLocalKeyInner<::std::cell::Cell<usize>> = ::std::thread::__FastLocalKeyInner::new();
#[allow(unused_unsafe)]
unsafe {
__KEY
.get(move || {
if let ::std::option::Option::Some(init) = init {
if let ::std::option::Option::Some(value) = init.take() {
return value;
} else if true {
::core::panicking::panic_fmt(
::core::fmt::Arguments::new_v1(
&["internal error: entered unreachable code: "],
&[
::core::fmt::ArgumentV1::new_display(
&::core::fmt::Arguments::new_v1(
&["missing default value"],
&[],
),
),
],
),
);
}
}
__init()
})
}
}
unsafe { ::std::thread::LocalKey::new(__getit) }
};
pub enum Foo {
First(bool),
Second(u32),
OutOfLine(SmallSliceBox<i32>),
}
#[automatically_derived]
#[repr(u8)]
pub enum ArchivedFoo
where
bool: ::rkyv::Archive,
u32: ::rkyv::Archive,
SmallSliceBox<i32>: ::rkyv::Archive,
{
#[allow(dead_code)]
First(
::rkyv::Archived<bool>,
),
#[allow(dead_code)]
Second(
::rkyv::Archived<u32>,
),
#[allow(dead_code)]
OutOfLine(
::rkyv::Archived<SmallSliceBox<i32>>,
),
}
#[automatically_derived]
pub enum FooResolver
where
bool: ::rkyv::Archive,
u32: ::rkyv::Archive,
SmallSliceBox<i32>: ::rkyv::Archive,
{
#[allow(dead_code)]
First(
::rkyv::Resolver<bool>,
),
#[allow(dead_code)]
Second(
::rkyv::Resolver<u32>,
),
#[allow(dead_code)]
OutOfLine(
::rkyv::Resolver<SmallSliceBox<i32>>,
),
}
#[automatically_derived]
const _: () = {
use ::core::marker::PhantomData;
use ::rkyv::{out_field, Archive, Archived};
#[repr(u8)]
enum ArchivedTag {
First,
Second,
OutOfLine,
}
#[repr(C)]
struct ArchivedVariantFirst(
ArchivedTag,
Archived<bool>,
PhantomData<Foo>,
)
where
bool: ::rkyv::Archive,
u32: ::rkyv::Archive,
SmallSliceBox<i32>: ::rkyv::Archive;
#[repr(C)]
struct ArchivedVariantSecond(
ArchivedTag,
Archived<u32>,
PhantomData<Foo>,
)
where
bool: ::rkyv::Archive,
u32: ::rkyv::Archive,
SmallSliceBox<i32>: ::rkyv::Archive;
#[repr(C)]
struct ArchivedVariantOutOfLine(
ArchivedTag,
Archived<SmallSliceBox<i32>>,
PhantomData<Foo>,
)
where
bool: ::rkyv::Archive,
u32: ::rkyv::Archive,
SmallSliceBox<i32>: ::rkyv::Archive;
impl Archive for Foo
where
bool: ::rkyv::Archive,
u32: ::rkyv::Archive,
SmallSliceBox<i32>: ::rkyv::Archive,
{
type Archived = ArchivedFoo;
type Resolver = FooResolver;
#[allow(clippy::unit_arg)]
#[inline]
unsafe fn resolve(
&self,
pos: usize,
resolver: Self::Resolver,
out: *mut Self::Archived,
) {
match resolver {
FooResolver::First(resolver_0) => {
match self {
Foo::First(self_0) => {
let out = out.cast::<ArchivedVariantFirst>();
(&raw mut (*out).0).write(ArchivedTag::First);
let (fp, fo) = {
#[allow(unused_unsafe)]
unsafe {
let fo = &raw mut (*out).1;
(fo.cast::<u8>().offset_from(out.cast::<u8>()) as usize, fo)
}
};
::rkyv::Archive::resolve(self_0, pos + fp, resolver_0, fo);
}
#[allow(unreachable_patterns)]
_ => ::core::hint::unreachable_unchecked(),
}
}
FooResolver::Second(resolver_0) => {
match self {
Foo::Second(self_0) => {
let out = out.cast::<ArchivedVariantSecond>();
(&raw mut (*out).0).write(ArchivedTag::Second);
let (fp, fo) = {
#[allow(unused_unsafe)]
unsafe {
let fo = &raw mut (*out).1;
(fo.cast::<u8>().offset_from(out.cast::<u8>()) as usize, fo)
}
};
::rkyv::Archive::resolve(self_0, pos + fp, resolver_0, fo);
}
#[allow(unreachable_patterns)]
_ => ::core::hint::unreachable_unchecked(),
}
}
FooResolver::OutOfLine(resolver_0) => {
match self {
Foo::OutOfLine(self_0) => {
let out = out.cast::<ArchivedVariantOutOfLine>();
(&raw mut (*out).0).write(ArchivedTag::OutOfLine);
let (fp, fo) = {
#[allow(unused_unsafe)]
unsafe {
let fo = &raw mut (*out).1;
(fo.cast::<u8>().offset_from(out.cast::<u8>()) as usize, fo)
}
};
::rkyv::Archive::resolve(self_0, pos + fp, resolver_0, fo);
}
#[allow(unreachable_patterns)]
_ => ::core::hint::unreachable_unchecked(),
}
}
}
}
}
};
#[automatically_derived]
const _: () = {
use ::rkyv::{Archive, Fallible, Serialize};
impl<__S: Fallible + ?Sized> Serialize<__S> for Foo
where
bool: Serialize<__S>,
u32: Serialize<__S>,
SmallSliceBox<i32>: Serialize<__S>,
{
#[inline]
fn serialize(
&self,
serializer: &mut __S,
) -> ::core::result::Result<Self::Resolver, __S::Error> {
Ok(
match self {
Self::First(_0) => {
FooResolver::First(Serialize::<__S>::serialize(_0, serializer)?)
}
Self::Second(_0) => {
FooResolver::Second(Serialize::<__S>::serialize(_0, serializer)?)
}
Self::OutOfLine(_0) => {
FooResolver::OutOfLine(
Serialize::<__S>::serialize(_0, serializer)?,
)
}
},
)
}
}
};
#[automatically_derived]
const _: () = {
use ::rkyv::{Archive, Archived, Deserialize, Fallible};
impl<__D: Fallible + ?Sized> Deserialize<Foo, __D> for Archived<Foo>
where
bool: Archive,
Archived<bool>: Deserialize<bool, __D>,
u32: Archive,
Archived<u32>: Deserialize<u32, __D>,
SmallSliceBox<i32>: Archive,
Archived<SmallSliceBox<i32>>: Deserialize<SmallSliceBox<i32>, __D>,
{
#[inline]
fn deserialize(
&self,
deserializer: &mut __D,
) -> ::core::result::Result<Foo, __D::Error> {
Ok(
match self {
Self::First(_0) => {
Foo::First(
Deserialize::<bool, __D>::deserialize(_0, deserializer)?,
)
}
Self::Second(_0) => {
Foo::Second(
Deserialize::<u32, __D>::deserialize(_0, deserializer)?,
)
}
Self::OutOfLine(_0) => {
Foo::OutOfLine(
Deserialize::<
SmallSliceBox<i32>,
__D,
>::deserialize(_0, deserializer)?,
)
}
},
)
}
}
};
#[repr(packed)]
pub struct SmallSliceBox<T> {
ptr: core::ptr::NonNull<T>,
size: u32,
}
pub struct SmallSliceBoxResolver<T>(
rkyv::boxed::BoxResolver<<[T] as ArchiveUnsized>::MetadataResolver>,
)
where
Box<[T]>: Archive,
[T]: ArchiveUnsized;
impl<T> Archive for SmallSliceBox<T>
where
Box<[T]>: Archive,
[T]: ArchiveUnsized,
{
type Archived = ArchivedBox<<[T] as ArchiveUnsized>::Archived>;
type Resolver = SmallSliceBoxResolver<T>;
#[inline]
unsafe fn resolve(
&self,
pos: usize,
resolver: Self::Resolver,
out: *mut Self::Archived,
) {
{
::std::io::_print(
::core::fmt::Arguments::new_v1(
&["Resolving ", "\n"],
&[::core::fmt::ArgumentV1::new_debug(&(&self as *const _))],
),
);
};
rkyv::boxed::ArchivedBox::resolve_from_ref(self.as_ref(), pos, resolver.0, out)
}
}
impl<S: rkyv::Fallible + ?Sized, T> Serialize<S> for SmallSliceBox<T>
where
Box<[T]>: Serialize<S>,
[T]: SerializeUnsized<S>,
{
#[inline]
fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
{
::std::io::_print(
::core::fmt::Arguments::new_v1(
&["Serializing ", "\n"],
&[::core::fmt::ArgumentV1::new_debug(&(&self as *const _))],
),
);
};
let res = ArchivedBox::serialize_from_ref(self.as_ref(), serializer)?;
Ok(SmallSliceBoxResolver(res))
}
}
impl<T, D> Deserialize<SmallSliceBox<T>, D>
for ArchivedBox<<[T] as ArchiveUnsized>::Archived>
where
[T]: ArchiveUnsized,
<[T] as ArchiveUnsized>::Archived: rkyv::DeserializeUnsized<[T], D>,
D: rkyv::Fallible + ?Sized,
{
fn deserialize(&self, deserializer: &mut D) -> Result<SmallSliceBox<T>, D::Error> {
{
::std::io::_print(
::core::fmt::Arguments::new_v1(
&["Deserializing ", "\n"],
&[::core::fmt::ArgumentV1::new_debug(&(&self as *const _))],
),
);
};
let boxed: Box<[T]> = self.deserialize(deserializer)?;
Ok(SmallSliceBox::from_box(boxed))
}
}
impl<T> SmallSliceBox<T> {
pub fn new(slice: &[T]) -> Self
where
T: Clone,
{
let boxed: Box<[T]> = slice.to_vec().into_boxed_slice();
Self::from_box(boxed)
}
pub unsafe fn new_unchecked(slice: &[T]) -> Self
where
T: Clone,
{
let boxed: Box<[T]> = slice.to_vec().into_boxed_slice();
Self::from_box_unchecked(boxed)
}
pub fn try_new(slice: &[T]) -> Result<Self, <u32 as TryFrom<usize>>::Error>
where
T: Clone,
{
let boxed: Box<[T]> = slice.to_vec().into_boxed_slice();
Self::try_from_box(boxed)
}
pub fn new_from_copy(slice: &[T]) -> Self
where
T: Copy,
{
let boxed: Box<[T]> = slice.into();
Self::from_box(boxed)
}
pub fn try_new_from_copy(slice: &[T]) -> Result<Self, <u32 as TryFrom<usize>>::Error>
where
T: Copy,
{
let boxed: Box<[T]> = slice.into();
Self::try_from_box(boxed)
}
pub fn try_from_box(
boxed: Box<[T]>,
) -> Result<Self, <u32 as TryFrom<usize>>::Error> {
{
::std::io::_print(::core::fmt::Arguments::new_v1(&["Hello\n"], &[]));
};
let size = boxed.len().try_into()?;
let fat_ptr = Box::into_raw(boxed);
let thin_ptr = fat_ptr as *mut T;
let ptr = unsafe { core::ptr::NonNull::new_unchecked(thin_ptr) };
let res = SmallSliceBox { ptr, size };
Ok(res)
}
pub fn from_box(boxed: Box<[T]>) -> Self {
Self::try_from_box(boxed).unwrap()
}
pub unsafe fn from_box_unchecked(boxed: Box<[T]>) -> Self {
Self::try_from_box(boxed).unwrap_unchecked()
}
}
impl<T> SmallSliceBox<T> {
pub fn to_box(this: Self) -> Box<[T]> {
{
::std::io::_print(::core::fmt::Arguments::new_v1(&["to_box called\n"], &[]));
};
let ptr = core::ptr::slice_from_raw_parts(this.ptr.as_ptr(), this.size as usize)
as *mut _;
let res = unsafe { Box::from_raw(ptr) };
core::mem::forget(this);
res
}
}
impl<T> Drop for SmallSliceBox<T> {
fn drop(&mut self) {
let me = std::mem::replace(
self,
SmallSliceBox {
ptr: NonNull::dangling(),
size: 0,
},
);
core::mem::forget(self);
let _drop_this_box = SmallSliceBox::to_box(me);
}
}
impl<T> Deref for SmallSliceBox<T> {
type Target = [T];
fn deref(&self) -> &Self::Target {
unsafe { core::slice::from_raw_parts(self.ptr.as_ptr(), self.size as usize) }
}
}
impl<T> DerefMut for SmallSliceBox<T> {
fn deref_mut(&mut self) -> &mut Self::Target {
unsafe { core::slice::from_raw_parts_mut(self.ptr.as_ptr(), self.size as usize) }
}
}
impl<T> core::borrow::Borrow<[T]> for SmallSliceBox<T> {
fn borrow(&self) -> &[T] {
&**self
}
}
impl<T> core::borrow::BorrowMut<[T]> for SmallSliceBox<T> {
fn borrow_mut(&mut self) -> &mut [T] {
&mut **self
}
}
impl<T> AsRef<[T]> for SmallSliceBox<T> {
fn as_ref(&self) -> &[T] {
&**self
}
}
impl<T> AsMut<[T]> for SmallSliceBox<T> {
fn as_mut(&mut self) -> &mut [T] {
&mut **self
}
}
impl<T> Unpin for SmallSliceBox<T> {}
impl<T> Clone for SmallSliceBox<T>
where
T: Clone,
{
fn clone(&self) -> Self {
let slice = self.deref();
unsafe { SmallSliceBox::new_unchecked(slice) }
}
}
impl<T: core::fmt::Debug> core::fmt::Debug for SmallSliceBox<T> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
core::fmt::Debug::fmt(&**self, f)
}
}
pub enum Thing {
LocalString { bytes: [u8; 14], len: u8 },
RemoteString { ptr: SmallSliceBox<u8> },
}