use core::{marker::PhantomData, mem::MaybeUninit};
use crate::{
At, Fields, Path, Pun, Variants,
layout::{Desc, Enum, Field, Layout, Variant},
};
const fn offset<F, E>(field: &F, whole: &MaybeUninit<E>) -> usize {
unsafe { core::ptr::from_ref(field).byte_offset_from(whole.as_ptr()) }.cast_unsigned()
}
trait Found: Sized {
const GIVEN: bool;
const SAMPLES: [MaybeUninit<Self>; 2];
const OFFSETS: [usize; 2];
const DESC: Desc<2>;
const TAG: Layout;
const VARIANTS: [Variant; 2];
const ENUM: Enum;
}
macro_rules! variant {
($e:ty, $variant:literal) => {
Variant::discovered(
$variant,
const { &<$e as Found>::DESC }.variant_ranges($variant),
<$e as Found>::DESC.holds_tag($variant),
const { &Layout::variant::<$e>(&[]) },
)
};
($e:ty, $variant:literal, $field:ty) => {
Variant::discovered(
$variant,
const { &<$e as Found>::DESC }.variant_ranges($variant),
<$e as Found>::DESC.holds_tag($variant),
const {
&Layout::variant::<$e>({
let fields: &'static [Field] = if <$e as Found>::DESC.inhabited($variant) {
const {
&Layout::sort_fields([Field::new(
<$e as Found>::OFFSETS[$variant],
&<$field as Pun>::LAYOUT,
)])
}
} else {
&[]
};
fields
})
},
)
};
}
impl<T: Pun> Found for Option<T> {
const GIVEN: bool = T::OPTION.is_some();
const SAMPLES: [MaybeUninit<Self>; 2] = if Self::GIVEN || !T::LAYOUT.is_inhabited() {
[Layout::wrap(None), Layout::uninit()]
} else {
[Layout::wrap(None), Layout::wrap(Some(unsafe { Layout::sample::<T>().assume_init() }))]
};
const OFFSETS: [usize; 2] = if Self::GIVEN || !T::LAYOUT.is_inhabited() {
[0, 0]
} else {
let sample = &<Self as Found>::SAMPLES[1];
match unsafe { &*sample.as_ptr() } {
Some(value) => [0, offset(value, sample)],
None => [0, 0],
}
};
const DESC: Desc<2> = if Self::GIVEN {
Desc::none()
} else {
Layout::discover::<Self, 2>(
&<Self as Found>::SAMPLES,
&[&[], &[Field::new(<Self as Found>::OFFSETS[1], &T::LAYOUT)]],
)
};
const TAG: Layout = const { &<Self as Found>::DESC }.tag();
const VARIANTS: [Variant; 2] = [variant!(Self, 0), variant!(Self, 1, T)];
const ENUM: Enum = Enum::discovered(
const { &<Self as Found>::TAG },
<Self as Found>::DESC.tag_offset(),
const { &<Self as Found>::VARIANTS },
Layout::size_align::<Self>(),
);
}
impl<T: Pun, E: Pun> Found for Result<T, E> {
const GIVEN: bool = false;
const SAMPLES: [MaybeUninit<Self>; 2] = [
if T::LAYOUT.is_inhabited() {
Layout::wrap(Ok(unsafe { Layout::sample::<T>().assume_init() }))
} else {
Layout::uninit()
},
if E::LAYOUT.is_inhabited() {
Layout::wrap(Err(unsafe { Layout::sample::<E>().assume_init() }))
} else {
Layout::uninit()
},
];
const OFFSETS: [usize; 2] = {
let (ok, err) = (&<Self as Found>::SAMPLES[0], &<Self as Found>::SAMPLES[1]);
let at = if T::LAYOUT.is_inhabited() {
match unsafe { &*ok.as_ptr() } {
Ok(value) => offset(value, ok),
Err(_) => 0,
}
} else {
0
};
let other = if E::LAYOUT.is_inhabited() {
match unsafe { &*err.as_ptr() } {
Err(value) => offset(value, err),
Ok(_) => 0,
}
} else {
0
};
[at, other]
};
const DESC: Desc<2> = Layout::discover::<Self, 2>(
&<Self as Found>::SAMPLES,
&[
&[Field::new(<Self as Found>::OFFSETS[0], &T::LAYOUT)],
&[Field::new(<Self as Found>::OFFSETS[1], &E::LAYOUT)],
],
);
const TAG: Layout = const { &<Self as Found>::DESC }.tag();
const VARIANTS: [Variant; 2] = [variant!(Self, 0, T), variant!(Self, 1, E)];
const ENUM: Enum = Enum::discovered(
const { &<Self as Found>::TAG },
<Self as Found>::DESC.tag_offset(),
const { &<Self as Found>::VARIANTS },
Layout::size_align::<Self>(),
);
}
unsafe impl<T: Pun> Pun for Option<T> {
type Elem = ();
type Fields = ();
type Variants = OptionNone<T>;
type Rules = ();
type Pointee = T::Pointee;
const PROBE: *const Self = core::ptr::null();
const LAYOUT: Layout = match T::OPTION {
Some(layout) => layout,
None => Layout::enumeration::<Self>(const { &<Self as Found>::ENUM }),
};
}
unsafe impl<T: Pun, E: Pun> Pun for Result<T, E> {
type Elem = ();
type Fields = ();
type Variants = ResultOk<T, E>;
type Rules = ();
type Pointee = ();
const PROBE: *const Self = core::ptr::null();
const LAYOUT: Layout = Layout::enumeration::<Self>(const { &<Self as Found>::ENUM });
}
#[doc(hidden)]
pub struct OptionNone<T>(PhantomData<T>);
#[doc(hidden)]
pub struct OptionSome<T>(PhantomData<T>);
#[doc(hidden)]
pub struct OptionSomeField<T>(PhantomData<T>);
#[doc(hidden)]
pub struct ResultOk<T, E>(PhantomData<(T, E)>);
#[doc(hidden)]
pub struct ResultErr<T, E>(PhantomData<(T, E)>);
#[doc(hidden)]
pub struct ResultOkField<T, E>(PhantomData<(T, E)>);
#[doc(hidden)]
pub struct ResultErrField<T, E>(PhantomData<(T, E)>);
const fn tag<E: Pun + Found>(index: usize) -> Option<u128> {
if E::GIVEN { None } else { Some(E::LAYOUT.variant_tag(index)) }
}
const fn ranges<E: Pun + Found>(index: usize) -> Option<&'static [(u128, u128)]> {
if E::GIVEN { None } else { E::LAYOUT.variant_ranges(index) }
}
const fn field<E: Pun + Found>(index: usize) -> Option<Field> {
if E::GIVEN || !E::DESC.inhabited(index) {
None
} else {
Some(*E::LAYOUT.variant_field(index, 0))
}
}
unsafe impl<T: Pun> Variants for OptionNone<T> {
type Fields = ();
type Next = OptionSome<T>;
const TAG: Option<u128> = tag::<Option<T>>(0);
const RANGES: Option<&'static [(u128, u128)]> = ranges::<Option<T>>(0);
}
unsafe impl<T: Pun> Variants for OptionSome<T> {
type Fields = OptionSomeField<T>;
type Next = ();
const TAG: Option<u128> = tag::<Option<T>>(1);
const RANGES: Option<&'static [(u128, u128)]> = ranges::<Option<T>>(1);
}
unsafe impl<T: Pun> Fields for OptionSomeField<T> {
type Type = T;
type Next = ();
type Last = ();
type Path<P: Path> = At<P, Self>;
const FIELD: Option<Field> = field::<Option<T>>(1);
}
unsafe impl<T: Pun, E: Pun> Variants for ResultOk<T, E> {
type Fields = ResultOkField<T, E>;
type Next = ResultErr<T, E>;
const TAG: Option<u128> = tag::<Result<T, E>>(0);
const RANGES: Option<&'static [(u128, u128)]> = ranges::<Result<T, E>>(0);
}
unsafe impl<T: Pun, E: Pun> Variants for ResultErr<T, E> {
type Fields = ResultErrField<T, E>;
type Next = ();
const TAG: Option<u128> = tag::<Result<T, E>>(1);
const RANGES: Option<&'static [(u128, u128)]> = ranges::<Result<T, E>>(1);
}
unsafe impl<T: Pun, E: Pun> Fields for ResultOkField<T, E> {
type Type = T;
type Next = ();
type Last = ();
type Path<P: Path> = At<P, Self>;
const FIELD: Option<Field> = field::<Result<T, E>>(0);
}
unsafe impl<T: Pun, E: Pun> Fields for ResultErrField<T, E> {
type Type = E;
type Next = ();
type Last = ();
type Path<P: Path> = At<P, Self>;
const FIELD: Option<Field> = field::<Result<T, E>>(1);
}