Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743// SPDX-License-Identifier: Apache-2.0 OR MIT
//! This module contains library internal items.//!//! These items must not be used outside of this crate and the pin-init-internal crate located at//! `../internal`.
#![expect(clippy::new_without_default, reason = "private API")]
use core::marker::PhantomPinned;use core::ops::Deref;
use super::*;
/// Zero-sized type used to mark a type as invariant.////// This is a polyfill for the [unstable type] in the standard library of the same name.////// See the [nomicon] for what subtyping is. See also [this table].////// [unstable type]: https://doc.rust-lang.org/nightly/std/marker/struct.PhantomInvariant.html/// [nomicon]: https://doc.rust-lang.org/nomicon/subtyping.html/// [this table]: https://doc.rust-lang.org/nomicon/phantom-data.html#table-of-phantomdata-patterns#[repr(transparent)]pub struct PhantomInvariant<T: ?Sized>(PhantomData<fn(T) -> T>);
impl<T: ?Sized> Clone for PhantomInvariant<T> { #[inline(always)] fn clone(&self) -> Self { *self }}
impl<T: ?Sized> Copy for PhantomInvariant<T> {}
impl<T: ?Sized> Default for PhantomInvariant<T> { #[inline(always)] fn default() -> Self { Self::new() }}
impl<T: ?Sized> PhantomInvariant<T> { #[inline(always)] pub const fn new() -> Self { Self(PhantomData) }}
/// Token type to signify successful initialization.////// Can only be constructed via the unsafe [`Self::new`] function. The initializer macros use this/// token type to prevent returning `Ok` from an initializer without initializing all fields.pub struct InitOk(());
impl InitOk { /// Creates a new token. /// /// # Safety /// /// This function may only be called from the `init!` macro in `../internal/src/init.rs`. #[inline(always)] pub unsafe fn new() -> Self { Self(()) }}
/// This trait is only implemented via the `#[pin_data]` proc-macro. It is used to facilitate/// the pin projections within the initializers.////// # Safety////// `pin-init` relies on the correctness of the helper functions defined on `PinData`./// Thus, only the `#[pin_data]` can implement this trait.#[diagnostic::on_unimplemented( message = "`{Self}` cannot be used with `pin_init!` macro", note = "did you forget to add `#[pin_data]` attribute to the struct?")]pub unsafe trait HasPinData { type PinData;
fn __pin_data(_: InitData<Self>) -> Self::PinData;}
/// This trait is automatically implemented for every type.////// It aims to provide type inference help; `PATH::__init_data()` would be able to retrieve an/// instance of `InitData<PATH<Generics>>` without having to mention the generics explicitly.pub trait HasInitData { #[inline] fn __init_data() -> InitData<Self> { InitData(PhantomInvariant::new()) }}
impl<T: ?Sized> HasInitData for T {}
pub struct InitData<T: ?Sized>(PhantomInvariant<T>);
impl<T: ?Sized> Clone for InitData<T> { #[inline] fn clone(&self) -> Self { *self }}
impl<T: ?Sized> Copy for InitData<T> {}
impl<T: ?Sized> InitData<T> { /// Type inference helper function. #[inline(always)] pub fn __make_closure<F, E>(self, f: F) -> F where F: FnOnce(*mut T, Self) -> Result<InitOk, E>, { f }
#[inline(always)] pub fn __with_lt(self) -> Self { self }}
/// Stack initializer helper type. Use [`stack_pin_init`] instead of this primitive.////// # Invariants////// If `self.is_init` is true, then `self.value` is initialized.////// [`stack_pin_init`]: crate::stack_pin_initpub struct StackInit<T> { value: MaybeUninit<T>, is_init: bool,}
impl<T> Drop for StackInit<T> { #[inline] fn drop(&mut self) { if self.is_init { // SAFETY: As we are being dropped, we only call this once. And since `self.is_init` is // true, `self.value` is initialized. unsafe { self.value.assume_init_drop() }; } }}
impl<T> StackInit<T> { /// Creates a new [`StackInit<T>`] that is uninitialized. Use [`stack_pin_init`] instead of this /// primitive. /// /// [`stack_pin_init`]: crate::stack_pin_init #[inline] pub fn uninit() -> Self { Self { value: MaybeUninit::uninit(), is_init: false, } }
/// Initializes the contents and returns the result. #[inline] pub fn init<E>(self: Pin<&mut Self>, init: impl PinInit<T, E>) -> Result<Pin<&mut T>, E> { // SAFETY: We never move out of `this`. let this = unsafe { Pin::into_inner_unchecked(self) }; // The value is currently initialized, so it needs to be dropped before we can reuse // the memory (this is a safety guarantee of `Pin`). if this.is_init { this.is_init = false; // SAFETY: `this.is_init` was true and therefore `this.value` is initialized. unsafe { this.value.assume_init_drop() }; } // SAFETY: The memory slot is valid and this type ensures that it will stay pinned. unsafe { init.__init(this.value.as_mut_ptr())? }; // INVARIANT: `this.value` is initialized above. this.is_init = true; // SAFETY: The slot is now pinned, since we will never give access to `&mut T`. Ok(unsafe { Pin::new_unchecked(this.value.assume_init_mut()) }) }}
#[test]#[cfg(feature = "std")]fn stack_init_reuse() { use ::std::{borrow::ToOwned, println, string::String}; use core::pin::pin;
#[derive(Debug)] struct Foo { a: usize, b: String, } let mut slot: Pin<&mut StackInit<Foo>> = pin!(StackInit::uninit()); let value: Result<Pin<&mut Foo>, core::convert::Infallible> = slot.as_mut().init(crate::init!(Foo { a: 42, b: "Hello".to_owned(), })); let value = value.unwrap(); println!("{value:?}"); let value: Result<Pin<&mut Foo>, core::convert::Infallible> = slot.as_mut().init(crate::init!(Foo { a: 24, b: "world!".to_owned(), })); let value = value.unwrap(); println!("{value:?}");}
// Marker types that determines type of `DropGuard`'s let bindings.pub struct Pinned;pub struct Unpinned;
/// Represent an uninitialized field.////// # Invariants////// - `ptr` is valid, properly aligned and points to uninitialized and exclusively accessed memory./// - If `P` is `Pinned`, then `ptr` is structurally pinned.pub struct Slot<P, T: ?Sized> { ptr: *mut T, _phantom: PhantomData<P>,}
impl<P, T: ?Sized> Slot<P, T> { /// # Safety /// /// - `ptr` is valid, properly aligned and points to uninitialized and exclusively accessed /// memory. /// - If `P` is `Pinned`, then `ptr` is structurally pinned. #[inline(always)] pub unsafe fn new(ptr: *mut T) -> Self { // INVARIANT: Per safety requirement. Self { ptr, _phantom: PhantomData, } }
/// Initialize the field by value. #[inline(always)] pub fn write(self, value: T) -> DropGuard<P, T> where T: Sized, { // SAFETY: `self.ptr` is a valid and aligned pointer for write. unsafe { self.ptr.write(value) } // SAFETY: // - `self.ptr` is valid and properly aligned per type invariant. // - `*self.ptr` is initialized above and the ownership is transferred to the guard. // - If `P` is `Pinned`, `self.ptr` is pinned. unsafe { DropGuard::new(self.ptr) } }}
impl<T: ?Sized> Slot<Unpinned, T> { /// Initialize the field. #[inline(always)] pub fn init<E>(self, init: impl Init<T, E>) -> Result<DropGuard<Unpinned, T>, E> { // SAFETY: // - `self.ptr` is valid and properly aligned. // - when `Err` is returned, we also propagate the error without touching `slot`; // also `self` is consumed so it cannot be touched further. unsafe { init.__init(self.ptr)? };
// SAFETY: // - `self.ptr` is valid and properly aligned per type invariant. // - `*self.ptr` is initialized above and the ownership is transferred to the guard. Ok(unsafe { DropGuard::new(self.ptr) }) }}
impl<T: ?Sized> Slot<Pinned, T> { /// Initialize the field. #[inline(always)] pub fn init<E>(self, init: impl PinInit<T, E>) -> Result<DropGuard<Pinned, T>, E> { // SAFETY: // - `self.ptr` is valid and properly aligned. // - when `Err` is returned, we also propagate the error without touching `ptr`; // also `self` is consumed so it cannot be touched further. // - the drop guard will not hand out `&mut` (only `Pin<&mut T>`). unsafe { init.__init(self.ptr)? };
// SAFETY: // - `self.ptr` is valid, properly aligned and pinned per type invariant. // - `*self.ptr` is initialized above and the ownership is transferred to the guard. Ok(unsafe { DropGuard::new(self.ptr) }) }}
/// When a value of this type is dropped, it drops a `T`.////// Can be forgotten to prevent the drop.////// # Invariants////// - `ptr` is valid and properly aligned./// - `*ptr` is initialized and owned by this guard./// - if `P` is `Pinned`, `ptr` is pinned.pub struct DropGuard<P, T: ?Sized> { ptr: *mut T, phantom: PhantomData<P>,}
impl<P, T: ?Sized> DropGuard<P, T> { /// Creates a drop guard and transfer the ownership of the pointer content. /// /// The ownership is only relinguished if the guard is forgotten via [`core::mem::forget`]. /// /// # Safety /// /// - `ptr` is valid and properly aligned. /// - `*ptr` is initialized, and the ownership is transferred to this guard. /// - if `P` is `Pinned`, `ptr` is pinned. #[inline] pub unsafe fn new(ptr: *mut T) -> Self { // INVARIANT: By safety requirement. Self { ptr, phantom: PhantomData, } }}
impl<T: ?Sized> DropGuard<Unpinned, T> { /// Create a let binding for accessor use. #[inline] pub fn let_binding(&mut self) -> &mut T { // SAFETY: Per type invariant. unsafe { &mut *self.ptr } }
/// Create a let binding for accessor use in dropck. #[inline] pub fn let_binding_in_dropck(&mut self) -> &mut T { self.let_binding() }}
impl<T: ?Sized> DropGuard<Pinned, T> { /// Create a let binding for accessor use. #[inline] pub fn let_binding(&mut self) -> Pin<&mut T> { // SAFETY: `self.ptr` is valid, properly aligned, initialized, exclusively accessible and // pinned per type invariant. unsafe { Pin::new_unchecked(&mut *self.ptr) } }
/// Create a let binding for accessor use in dropck. #[inline] pub fn let_binding_in_dropck(&mut self) -> Pin<&mut T> { self.let_binding() }}
impl<P, T: ?Sized> Drop for DropGuard<P, T> { #[inline] fn drop(&mut self) { // SAFETY: `self.ptr` is valid, properly aligned and `*self.ptr` is owned by this guard. unsafe { ptr::drop_in_place(self.ptr) } }}
pub struct Shared;pub struct Mutable;
/// Represent an uninitialized field in a pinned struct that will be referenced by other fields.////// # Invariants////// - `ptr` is valid, properly aligned and points to uninitialized and exclusively accessed memory/// and will live longer than `'a`./// - If `P` is `Pinned`, then `ptr` is structurally pinned.pub struct SelfRefSlot<'a, M, P, T: ?Sized> { ptr: *mut T, _phantom: PhantomData<(M, P, &'a mut T)>,}
impl<'a, M, P, T: ?Sized> SelfRefSlot<'a, M, P, T> { /// # Safety /// /// - `ptr` is valid, properly aligned and points to uninitialized and exclusively accessed /// memory and will live longer than `'a`. /// - If `P` is `Pinned`, then `ptr` is structurally pinned. #[inline] pub unsafe fn new(ptr: *mut T) -> Self { // INVARIANT: Per safety requirement. Self { ptr, _phantom: PhantomData, } }
/// Initialize the field by value. #[inline] pub fn write(self, value: T) -> SelfRefDropGuard<'a, M, P, T> where T: Sized, { // SAFETY: `self.ptr` is a valid and aligned pointer for write. unsafe { self.ptr.write(value) } // SAFETY: // - `self.ptr` is valid, properly aligned and live longer than `'a` per type invariant. // - `*self.ptr` is initialized above and the ownership is transferred to the guard. // - If `P` is `Pinned`, `self.ptr` is pinned. unsafe { SelfRefDropGuard::new(self.ptr) } }}
impl<'a, M, T: ?Sized> SelfRefSlot<'a, M, Unpinned, T> { /// Initialize the field. #[inline] pub fn init<E>(self, init: impl Init<T, E>) -> Result<SelfRefDropGuard<'a, M, Unpinned, T>, E> { // SAFETY: // - `self.ptr` is valid and properly aligned. // - when `Err` is returned, we also propagate the error without touching `ptr`; // also `self` is consumed so it cannot be touched further. unsafe { init.__init(self.ptr)? };
// SAFETY: // - `self.ptr` is valid, properly aligned and live longer than `'a` per type invariant. // - `*self.ptr` is initialized above and the ownership is transferred to the guard. Ok(unsafe { SelfRefDropGuard::new(self.ptr) }) }}
impl<'a, M, T: ?Sized> SelfRefSlot<'a, M, Pinned, T> { /// Initialize the field. #[inline] pub fn init<E>( self, init: impl PinInit<T, E>, ) -> Result<SelfRefDropGuard<'a, M, Pinned, T>, E> { // SAFETY: // - `ptr` is valid // - when `Err` is returned, we also propagate the error without touching `ptr`; // also `self` is consumed so it cannot be touched further. // - the drop guard will not hand out `&mut` (only `Pin<&mut T>`). unsafe { init.__init(self.ptr)? };
// SAFETY: // - `self.ptr` is valid, properly aligned and live longer than `'a` per type invariant. // - `*self.ptr` is initialized above and the ownership is transferred to the guard. Ok(unsafe { SelfRefDropGuard::new(self.ptr) }) }}/// When a value of this type is dropped, it drops a `T`.////// Can be forgotten to prevent the drop.////// # Invariants////// - `ptr` is valid, properly aligned and live longer than `'a`./// - `*ptr` is initialized and owned by this guard./// - if `P` is `Pinned`, `ptr` is pinned.pub struct SelfRefDropGuard<'a, M, P, T: ?Sized> { ptr: *mut T, phantom: PhantomData<(M, P, &'a mut T)>,}
impl<'a, M, P, T: ?Sized> SelfRefDropGuard<'a, M, P, T> { /// Creates a drop guard and transfer the ownership of the pointer content. /// /// The ownership is only relinquished if the guard is forgotten via [`core::mem::forget`]. /// /// # Safety /// /// - `ptr` is valid, properly aligned and live longer than `'a`. /// - `*ptr` is initialized, and the ownership is transferred to this guard. /// - if `P` is `Pinned`, `ptr` is pinned. #[inline] pub unsafe fn new(ptr: *mut T) -> Self { // INVARIANT: By safety requirement. Self { ptr, phantom: PhantomData, } }}
impl<'a, T: ?Sized> SelfRefDropGuard<'a, Shared, Unpinned, T> { /// Create a let binding for accessor use. #[inline] pub fn let_binding(&mut self) -> &'a T { // SAFETY: Per type invariant. unsafe { &*self.ptr } }
/// Create a let binding for accessor use in dropck. #[inline] pub fn let_binding_in_dropck(&mut self) -> &T { self.let_binding() }}
impl<'a, T: ?Sized> SelfRefDropGuard<'a, Shared, Pinned, T> { /// Create a let binding for accessor use. #[inline] pub fn let_binding(&mut self) -> Pin<&'a T> { // SAFETY: `self.ptr` is valid, properly aligned, live longer than `'a`, initialized, // exclusively accessible and pinned per type invariant. unsafe { Pin::new_unchecked(&*self.ptr) } }
/// Create a let binding for accessor use in dropck. #[inline] pub fn let_binding_in_dropck(&mut self) -> Pin<&T> { self.let_binding() }}
impl<'a, T: ?Sized> SelfRefDropGuard<'a, Mutable, Unpinned, T> { /// Create a let binding for accessor use. #[inline] pub fn let_binding(&mut self) -> &'a mut T { // SAFETY: Per type invariant. unsafe { &mut *self.ptr } }
/// Create a let binding for accessor use in dropck. #[inline] pub fn let_binding_in_dropck(&mut self) -> &mut T { self.let_binding() }}
impl<'a, T: ?Sized> SelfRefDropGuard<'a, Mutable, Pinned, T> { /// Create a let binding for accessor use. #[inline] pub fn let_binding(&mut self) -> Pin<&'a mut T> { // SAFETY: `self.ptr` is valid, properly aligned, live longer than `'a`, initialized, // exclusively accessible and pinned per type invariant. unsafe { Pin::new_unchecked(&mut *self.ptr) } }
#[inline] pub fn let_binding_in_dropck(&mut self) -> Pin<&mut T> { self.let_binding() }}
impl<M, P, T: ?Sized> Drop for SelfRefDropGuard<'_, M, P, T> { #[inline] fn drop(&mut self) { // SAFETY: `self.ptr` is valid, properly aligned and `*self.ptr` is owned by this guard. unsafe { ptr::drop_in_place(self.ptr) } }}
/// Token used by `PinnedDrop` to prevent calling the function without creating this unsafely/// created struct. This is needed, because the `drop` function is safe, but should not be called/// manually.pub struct OnlyCallFromDrop(());
impl OnlyCallFromDrop { /// # Safety /// /// This function should only be called from the [`Drop::drop`] function and only be used to /// delegate the destruction to the pinned destructor [`PinnedDrop::drop`] of the same type. pub unsafe fn new() -> Self { Self(()) }}
/// Initializer that always fails.////// Used by [`assert_pinned!`].////// [`assert_pinned!`]: crate::assert_pinnedpub struct AlwaysFail<T: ?Sized> { _t: PhantomData<T>,}
impl<T: ?Sized> AlwaysFail<T> { /// Creates a new initializer that always fails. #[inline] pub fn new() -> Self { Self { _t: PhantomData } }}
impl<T: ?Sized> Default for AlwaysFail<T> { #[inline] fn default() -> Self { Self::new() }}
// SAFETY: `__init` always fails, which is always okay.unsafe impl<T: ?Sized> PinInit<T, ()> for AlwaysFail<T> { #[inline] unsafe fn __init(self, _slot: *mut T) -> Result<(), ()> { Err(()) }}/// Polyfill of `FnOnce` trait to be able to reference output via associated type.pub trait FnOutput<Args> { type Output;}
macro_rules! impl_fn_output { () => {}; ($ret:ident, $($arg:ident,)*) => { impl<This, $ret, $($arg,)*> FnOutput<($($arg,)*)> for This where This: FnOnce($($arg,)*) -> $ret, { type Output = $ret; } impl_fn_output!($($arg,)*); };}
impl_fn_output!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U,);
/// Lifetime erasure facility.////// Say we have `exists<'a, 'b> Foo<'a, 'b>` and we want to store it. There's no concrete/// lifetimes we can use, so we want to erase the lifetime.////// Such erasure can be encoded as/// `Erased<for<'a> fn(&'a ()) -> for<'b> fn(&'b()) -> (Foo<'a, 'b>,)`.////// This can be considered the stable version of Rust's `unsafe_binder` feature, without the/// no-drop-glue requirement.#[repr(transparent)]#[allow(private_bounds)]pub struct Erase<F: EraseLt>(F::Erased);
/// Helper trait to resolve the erased lifetime.trait EraseLt { type Erased;}
impl<T> EraseLt for (T,) { type Erased = T;}
impl<T> EraseLt for Twhere T: for<'a> FnOutput<(&'a (),), Output: EraseLt>,{ type Erased = <<T as FnOutput<(&'static (),)>>::Output as EraseLt>::Erased;}
// The default `Send` and `Sync` are not sufficient, because one can use lifetime specialization to// implement `Send` or `Sync` for a concrete instance of lifetime. Use HRTB to ensure that the type// will only implement `Send` or `Sync` if it's implemented for *all* erased lifetimes.
// SAFETY: Trivial, no lifetime to erase.unsafe impl<T: Send> Send for Erase<(T,)> {}
// SAFETY: If we erased a lifetime, then the type needs to be `Send` for across *all* that// lifetimes.unsafe impl<F: EraseLt> Send for Erase<F>where F: for<'a> FnOutput<(&'a (),), Output: EraseLt>, for<'a> Erase<<F as FnOutput<(&'a (),)>>::Output>: Send,{}
// SAFETY: Trivial, no lifetime to erase.unsafe impl<T: Sync> Sync for Erase<(T,)> {}
// SAFETY: If we erased a lifetime, then the type needs to be `Sync` for across *all* that// lifetimes.unsafe impl<F: EraseLt> Sync for Erase<F>where F: for<'a> FnOutput<(&'a (),), Output: EraseLt>, for<'a> Erase<<F as FnOutput<(&'a (),)>>::Output>: Sync,{}
/// Wrapper for borrowed fields.////// This should be switched to `UnsafePinned` when it is stable./// NOTE: This type needs to be covariant; Rust's 1.89+'s `UnsafePinned` is invariant.#[repr(transparent)]pub struct Borrowed<T: ?Sized, P>(PhantomInvariant<P>, PhantomPinned, T);
// Lifetimes not needed by drop glue are considered by Rust's drop check to be considered// `#[may_dangle]`. In case for a self-referential struct, we may have fields which need lifetime of// borrowed fields in their drop glue, so compiler's automatic check is insufficient.//// Code like this:// ```// #[pin_data]// struct SelfRef<'a> {// borrow: PrintOnDrop<&'owner str>,// owner: &'a str,// }// ```// may access `owner` during the drop, however Rust will determine that since `'a` only is used in// `owner`, the `'a` lifetime may dangle during drop.//// This is undesirable for pin-init self references, because `&'a str` could be coerecd to// `&'owner str` and this could further coerce if there're implied outlives, e.g.// `&'earlier_field &'owner ()` would allow `&'owner str` to further coerce to `&'earlier_field`.//// Thus, if any self-referential field require field lifetime access in `Drop` impl, we would need// to ensure that the all generic parameters visible by self-referential fields would strictly// outlive the struct. And this can be done by a simple `Drop` impl that does nothing. Without a// dropck eye patch, presence of `Drop` impl, albeit empty, tells the drop check that the strict// outlive relation is needed.impl<T: ?Sized, P> Drop for Borrowed<T, P> { #[inline(always)] fn drop(&mut self) {}}
impl<T: ?Sized, P> Deref for Borrowed<T, P> { type Target = T;
#[inline(always)] fn deref(&self) -> &T { &self.2 }}
/// An alias of `PhantomData` but with a name to aid user in case of misuse.pub struct NotVisible<T: ?Sized>(PhantomData<T>);
impl<T: ?Sized> NotVisible<T> { #[inline(always)] pub fn new() -> Self { Self(PhantomData) }}
/// Marker type to capture outlive bounds coming from existential lifetimes.pub struct ExistLt<'a>(PhantomData<&'a ()>);
// Dummy `Drop`, same reason as `Borrowed`.impl Drop for ExistLt<'_> { #[inline(always)] fn drop(&mut self) {}}
/// Type that allows additional `PhantomData` to be attached.////// This allows changing variance of types without introducing additional fields.#[repr(transparent)]pub struct WithPhantom<T, P>(PhantomData<P>, T);