#![allow(internal_features)] // for `unsized_fn_params`

pub extern crate alloc as alloc_crate;

extern crate std;

use alloc_crate::{alloc, boxed::Box, ffi::CString, rc::Rc, string::String, sync::Arc, vec::Vec};

use core::{

alloc::Layout,

ffi::CStr,

marker::{PhantomData, Unsize},

mem::{self, ManuallyDrop, MaybeUninit},

ops::FnMut,

pin::Pin,

ptr::{self, addr_of, Pointee},

use std::{

ffi::{OsStr, OsString},

path::{Path, PathBuf},

pub mod macro_exports {

macro_rules! unsize {

macro_rules! by_value_str {

mod with_emplacable_for {

use with_emplacable_for::with_emplacable_closure;

pub use with_emplacable_for::WithEmplacableForFn;

pub fn with_emplacable_for<T, F, R>(mut val: T, mut f: F) -> R

pub trait EmplacableFn<T>: for<'a> FnOnce(&'a mut Emplacer<'_, T>)

impl<T, F> EmplacableFn<T> for F

pub struct Emplacable<T, F>

impl<T, F> Emplacable<T, F>

T: ?Sized,

F: EmplacableFn<T>,

/// Create a new `Emplacable` from a closure.

/// This is only useful if you are implementing

/// a function that returns an unsized value as

/// an [`Emplacable`].

///

/// # Safety

///

/// The closure `closurse` *must*, either diverge

/// without returning, or, if it returns, then

/// it must have used the emplacer to fully

/// initalize the value.

#[must_use]

#[inline]

pub unsafe fn from_fn(closure: F) -> Self {

}

/// Returns the closure inside this `Emplacable`.

///

/// This is only useful if you are implementing

/// a function like [`box_new_with`].

#[must_use]

#[inline]

pub fn into_fn(self) -> F {

}

/// Emplaces this sized `T` onto the stack.

#[must_use]

#[inline]

pub fn get(self) -> T

}

/// Runs the `Emplacable` closure,

/// but doesn't run the "inner closure",

/// so the value of type `T` is forgotten,

/// and its destructor is not run.

///

/// If you want to drop the `T` and run its destructor,

/// drop the `Emplacable` instead.

#[inline]

pub fn forget(self) {

}

/// Turns an emplacer for a sized type into one for an unsized type

/// via an unsizing coercion (for example, array -> slice or

/// concrete type -> trait object).

#[must_use]

#[inline]

pub fn unsize<U: ?Sized>(self) -> Emplacable<U, impl EmplacableFn<U>>

}

/// Creates an `Emplacable` for a slice of values of type `T` out of an iterator

/// of values of type `T`.

///

/// This function differs from [`FromIterator::from_iter`] in that the iterator is required to

/// be an [`ExactSizeIterator`]. If `ExactSizeIterator` is incorrectly implemented,

/// this function may panic or otherwise misbehave (but will not trigger UB).

#[allow(clippy::should_implement_trait)] // We only take `ExactSizeIterator`s

#[inline]

pub fn from_iter<I>(iter: I) -> Emplacable<[T], impl EmplacableFn<[T]>>

where

T: Sized,

I: IntoIterator<Item = Self>,

I::IntoIter: ExactSizeIterator,

{

fn from_iter_inner<

T,

F: EmplacableFn<T>,

I: Iterator<Item = Emplacable<T, F>> + ExactSizeIterator,

>(

iter: I,

) -> Emplacable<[T], impl EmplacableFn<[T]>> {

let len = iter.len();

// Panics if size overflows `isize::MAX`.

let layout = Layout::from_size_align(

mem::size_of::<T>().checked_mul(len).unwrap(),

mem::align_of::<T>(),

)

.unwrap();

let slice_emplacer_closure = move |slice_emplacer: &mut Emplacer<'_, [T]>| {

// Move ite into closure

let emplacables_iter = ManuallyDrop::new(iter);

// SAFETY: we fulfill the preconditions

let slice_emplacer_fn = unsafe { slice_emplacer.into_fn() };

slice_emplacer_fn(layout, len, &mut |arr_out_ptr: *mut PhantomData<[T]>| {

if !arr_out_ptr.is_null() {

let elem_emplacables: I =

// SAFETY: this "inner closure" can only be called once,

// per preconditions of `Emplacer::new`.

// `elem_emplacables` is inside a `ManuallyDrop`, so avoid double-drop.

unsafe { ptr::read(&*emplacables_iter) };

// We can't trust `ExactSizeIterator`'s `len()`,

// so we keep track of how many

// elements were actually returned.

let mut num_elems_copied: usize = 0;

let indexed_elem_emplacables = (0..len).zip(elem_emplacables);

indexed_elem_emplacables.for_each(|(index, elem_emplacable)| {

let elem_emplacable_closure = elem_emplacable.into_fn();

let elem_emplacer_closure = &mut move |

_: Layout,

(),

inner_closure: &mut dyn FnMut(*mut PhantomData<T>),

| {

// SAFETY: by fn precondition

inner_closure(unsafe { arr_out_ptr.cast::<T>().add(index).cast() });

};

// SAFETY: `elem_emplacer_closure` passes a pointer with the correct offset from the

// start of the allocation

let elem_emplacer = unsafe { Emplacer::from_fn(elem_emplacer_closure) };

elem_emplacable_closure(elem_emplacer);

num_elems_copied += 1;

});

assert_eq!(num_elems_copied, len);

} else {

let emplacables_iter: I =

// SAFETY: this "inner closure" can only be called once,

// per preconditions of `Emplacer::new`.

// `elem_emplacables` is inside a `ManuallyDrop`, so avoid double-drop.

unsafe { ptr::read(&*emplacables_iter) };

for _emplacable in emplacables_iter {

// drop `emplacable`

}

}

});

};

// SAFETY: `closure` properly emplaces `val`

unsafe { Emplacable::from_fn(slice_emplacer_closure) }

}

let emplacables_iter = iter.into_iter();

from_iter_inner(emplacables_iter)

}

impl<T, F> Drop for Emplacable<T, F>

where

T: ?Sized,

F: EmplacableFn<T>,

/// Runs the contained closure to completion,

/// instructing it to drop the value of type `T`.

fn drop(&mut self) {

}

pub trait IntoEmplacable<T: ?Sized> {

impl<T> IntoEmplacable<T> for T {

impl<T> From<T> for Emplacable<T, <T as IntoEmplacable<T>>::Closure> {

trait CopyToBuf: Sized {

impl<T: Clone> CopyToBuf for T {

impl<T: Copy> CopyToBuf for T {

impl<'s, T: Clone + 's> IntoEmplacable<[T]> for &'s [T] {

type Closure = impl for<'a> FnOnce(&'a mut Emplacer<'_, [T]>) + 's;

#[inline]

fn into_emplacable(self) -> Emplacable<[T], Self::Closure> {

}

impl<'s, T: Clone + 's> From<&'s [T]>

for Emplacable<[T], <&'s [T] as IntoEmplacable<[T]>>::Closure>

impl<'s> IntoEmplacable<str> for &'s str {

type Closure = impl for<'a> FnOnce(&'a mut Emplacer<'_, str>) + 's;

#[inline]

fn into_emplacable(self) -> Emplacable<str, Self::Closure> {

}

impl<'s> From<&'s str> for Emplacable<str, <&'s str as IntoEmplacable<str>>::Closure> {

impl<'s> IntoEmplacable<CStr> for &'s CStr {

type Closure = impl for<'a> FnOnce(&'a mut Emplacer<'_, CStr>) + 's;

#[inline]

fn into_emplacable(self) -> Emplacable<CStr, Self::Closure> {

}

impl<'s> From<&'s CStr> for Emplacable<CStr, <&'s CStr as IntoEmplacable<CStr>>::Closure> {

impl<'s> IntoEmplacable<OsStr> for &'s OsStr {

type Closure = impl for<'a> FnOnce(&'a mut Emplacer<'_, OsStr>) + 's;

#[inline]

fn into_emplacable(self) -> Emplacable<OsStr, Self::Closure> {

}

impl<'s> From<&'s OsStr> for Emplacable<OsStr, <&'s OsStr as IntoEmplacable<OsStr>>::Closure> {