eros 0.8.1

use alloc::boxed::Box;
#[cfg(feature = "context")]
use alloc::vec::Vec;
use core::any::Any;
#[cfg(not(feature = "std"))]
use core::any::TypeId;
use core::fmt;
use core::marker::PhantomData;
use core::mem;
use core::ops::Deref;
use core::ptr;
#[cfg(feature = "std")]
use std::any::TypeId;

#[cfg(feature = "context")]
use crate::context::ContextFrame;
use crate::context::ContextValue;
use crate::formatting::Report;
use crate::type_set::{
    Contains, NarrowTarget, RecoveryHandler, RecoveryTarget, SupersetOf, TupleForm, TypeSet,
};

use crate::AnyError;

/// Any error that satisfies this trait's bounds can be used in a `ErrorUnion`
pub trait SendSyncError: core::any::Any + core::error::Error + Send + Sync + 'static {
    /// Converts this `SendSynError` to `Any`.
    ///
    /// Warning: Use carefully since `Any` is this type,
    /// not the underlying type. e.g. For `x: Box<dyn SendSyncError>` with `x.as_any()`,
    /// the type yielded is `Box<dyn SendSyncError>` so functions like `x.is::<T>()` will not work as expected.
    /// While one would probably want `(&*x as &dyn Any)` which is the underlying and `x.is::<T>()`
    /// will work as expected.
    ///
    /// The main use case for this function is when `x: &dyn SendSyncError`.
    /// In such case `x.is::<T>()` will likely work as intended.
    fn as_any(&self) -> &dyn Any;
}

impl<T> SendSyncError for T
where
    T: core::error::Error + core::any::Any + Send + Sync + 'static,
{
    fn as_any(&self) -> &dyn Any {
        self
    }
}

impl core::error::Error for Box<dyn SendSyncError> {
    fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
        Some(&**self)
    }
}

// Without metadata, into_inner reuses this allocation as a Box of the error.
#[cfg_attr(
    not(any(feature = "backtrace", feature = "context", feature = "location")),
    repr(transparent)
)]
pub(crate) struct ErrorUnionInner<T: ?Sized> {
    #[cfg(feature = "backtrace")]
    pub(crate) backtrace: std::backtrace::Backtrace,
    #[cfg(feature = "context")]
    pub(crate) context: Vec<ContextFrame>,
    #[cfg(feature = "location")]
    pub(crate) location: &'static core::panic::Location<'static>,
    /// Re-boxes the error field into a fresh allocation.
    /// Stored at construction so the concrete type is still known.
    #[cfg(any(feature = "backtrace", feature = "context", feature = "location"))]
    pub(crate) into_box_fn: fn(*mut dyn SendSyncError) -> Box<dyn SendSyncError>,
    pub(crate) error: T,
}

#[cfg(any(feature = "backtrace", feature = "context", feature = "location"))]
fn make_box<T: SendSyncError>(ptr: *mut dyn SendSyncError) -> Box<dyn SendSyncError> {
    // SAFETY: caller guarantees ptr points to a live T
    let value: T = unsafe { ptr::read(ptr as *const dyn SendSyncError as *const T) };
    Box::new(value)
}

impl ErrorUnionInner<dyn SendSyncError> {
    #[cfg_attr(feature = "location", track_caller)]
    pub(crate) fn new<T>(t: T) -> Box<ErrorUnionInner<dyn SendSyncError>>
    where
        T: SendSyncError,
    {
        Box::new(ErrorUnionInner {
            #[cfg(feature = "backtrace")]
            backtrace: std::backtrace::Backtrace::capture(),
            #[cfg(feature = "context")]
            context: Vec::new(),
            #[cfg(feature = "location")]
            location: core::panic::Location::caller(),
            #[cfg(any(feature = "backtrace", feature = "context", feature = "location"))]
            into_box_fn: make_box::<T>,
            error: t,
        })
    }

    pub(crate) fn new_from_parts<T>(
        t: T,
        #[cfg(feature = "backtrace")] backtrace: std::backtrace::Backtrace,
        #[cfg(feature = "context")] context: Vec<ContextFrame>,
        #[cfg(feature = "location")] location: &'static core::panic::Location<'static>,
    ) -> Box<ErrorUnionInner<dyn SendSyncError>>
    where
        T: SendSyncError,
    {
        Box::new(ErrorUnionInner {
            #[cfg(feature = "backtrace")]
            backtrace,
            #[cfg(feature = "context")]
            context,
            #[cfg(feature = "location")]
            location,
            #[cfg(any(feature = "backtrace", feature = "context", feature = "location"))]
            into_box_fn: make_box::<T>,
            error: t,
        })
    }

    #[allow(unstable_name_collisions)]
    pub(crate) fn is_error<T: 'static>(&self) -> bool {
        self.error.type_id() == TypeId::of::<T>()
    }

    pub(crate) unsafe fn downcast_error_unchecked<T: 'static>(self: Box<Self>) -> T {
        debug_assert!(self.is_error::<T>());

        // Note: this prevents the Box from automatically dropping at the end of the function.
        let raw_container: *mut Self = Box::into_raw(self);

        unsafe {
            // Thin the fat pointer directly — no intermediate dyn Any cast needed.
            // addr_of! gives *const dyn SendSyncError (fat), casting to *const T thins it.
            let thin_ptr = ptr::addr_of!((*raw_container).error) as *const T;
            // Copy to the stack
            let downcasted_value: T = ptr::read(thin_ptr);

            // Destructively drop the remaining fields inside the container
            #[cfg(feature = "backtrace")]
            ptr::drop_in_place(ptr::addr_of_mut!((*raw_container).backtrace));
            #[cfg(feature = "context")]
            ptr::drop_in_place(ptr::addr_of_mut!((*raw_container).context));
            #[cfg(feature = "location")]
            ptr::drop_in_place(ptr::addr_of_mut!((*raw_container).location));

            // Deallocate the Box allocation itself.
            // We reconstruct a Box containing uninitialized/dead data, but wrapped in
            // ManuallyDrop so its fields aren't dropped. When this `dead_box` goes out of scope,
            // it frees the underlying heap memory without touching the fields.
            let _dead_box: Box<mem::ManuallyDrop<Self>> =
                Box::from_raw(raw_container as *mut mem::ManuallyDrop<Self>);

            downcasted_value
        }
    }

    pub(crate) unsafe fn downcast_error_unchecked_with_parts<T: 'static>(
        self: Box<Self>,
    ) -> ErrorUnionInner<T> {
        debug_assert!(self.is_error::<T>());

        // Note: this prevents the Box from automatically dropping at the end of the function.
        let raw_container: *mut Self = Box::into_raw(self);

        unsafe {
            // Thin the fat pointer directly — no intermediate dyn Any cast needed.
            // addr_of! gives *const dyn SendSyncError (fat), casting to *const T thins it.
            let thin_ptr = ptr::addr_of!((*raw_container).error) as *const T;
            // Copy to the stack
            let downcasted_value: T = ptr::read(thin_ptr);

            // Read the additional parts before dropping
            #[cfg(feature = "backtrace")]
            let backtrace = ptr::read(ptr::addr_of!((*raw_container).backtrace));
            #[cfg(feature = "context")]
            let context = ptr::read(ptr::addr_of!((*raw_container).context));
            #[cfg(feature = "location")]
            let location = ptr::read(ptr::addr_of!((*raw_container).location));

            #[cfg(any(feature = "backtrace", feature = "context", feature = "location"))]
            let into_box_fn = ptr::read(ptr::addr_of!((*raw_container).into_box_fn));

            // Deallocate the Box allocation itself.
            // We reconstruct a Box containing uninitialized/dead data, but wrapped in
            // ManuallyDrop so its fields aren't dropped. When this `dead_box` goes out of scope,
            // it frees the underlying heap memory without touching the fields.
            let _dead_box: Box<mem::ManuallyDrop<Self>> =
                Box::from_raw(raw_container as *mut mem::ManuallyDrop<Self>);

            ErrorUnionInner {
                #[cfg(feature = "backtrace")]
                backtrace,
                #[cfg(feature = "context")]
                context,
                #[cfg(feature = "location")]
                location,
                #[cfg(any(feature = "backtrace", feature = "context", feature = "location"))]
                into_box_fn,
                error: downcasted_value,
            }
        }
    }

    pub(crate) fn downcast_error_ref<T: 'static>(&self) -> Option<&T> {
        (&self.error as &dyn Any).downcast_ref::<T>()
    }

    // todo when https://github.com/rust-lang/rust/issues/90850 is stabilized
    // pub(crate) unsafe fn downcast_unchecked_error_ref<T: 'static>(&self) -> &T {
    //     debug_assert!(self.is_error::<T>());
    //     unsafe { (&self.error as &dyn Any).downcast_unchecked_ref::<T>() }
    // }

    pub(crate) fn downcast_error_mut<T: 'static>(&mut self) -> Option<&mut T> {
        (&mut self.error as &mut dyn Any).downcast_mut::<T>()
    }

    // todo when https://github.com/rust-lang/rust/issues/90850 is stabilized
    // pub(crate) unsafe fn downcast_unchecked_error_mut<T: 'static>(&mut self) -> &mut T {
    //     debug_assert!(self.is_error::<T>());
    //     unsafe { (&mut self.error as &mut dyn Any).downcast_unchecked_mut::<T>() }
    // }
}

/// `ErrorUnion` is an open sum type of errors. It differs from an enum
/// in that you do not need to define any actual new type
/// in order to hold some specific combination of variants,
/// but rather you simply describe the ErrorUnion as holding
/// one value out of several specific possibilities,
/// defined by using a tuple of those possible variants
/// as the generic parameter for the `ErrorUnion`.
/// Every tuple member must implement [`SendSyncError`].
///
/// For example, a `ErrorUnion<(io::Error, fmt::Error)>` contains either
/// a `io::Error` or a `fmt::Error`. The benefit of this over creating
/// specific enums for each function become apparent in larger
/// codebases where error handling needs to occur in
/// different places for different errors. As such, `ErrorUnion` allows
/// you to quickly specify a function's return value as
/// involving a precise subset of errors that the caller
/// can clearly reason about. Providing maximum composability with
/// no boilerplate.
///
/// When the exact error type does not matter, `ErrorUnion<AnyError>` represents
/// the set of all possible errors.
///
/// `ErrorUnion` also holds information surrounding the error depending on feature
/// flags enabled. This may include `Backtrace` and/or `Location`. Context can be added throughout
/// the call stack.
pub struct ErrorUnion<E: TypeSet = AnyError> {
    pub(crate) inner: Box<ErrorUnionInner<dyn SendSyncError>>,
    // TypeId checks require exact variant types. A subtype coercion of E could
    // change a variant's TypeId and select the wrong unchecked enum downcast.
    pub(crate) _pd: PhantomData<fn(E) -> E>,
}

impl<T> Deref for ErrorUnion<(T,)>
where
    T: SendSyncError,
{
    type Target = T;

    fn deref(&self) -> &T {
        (&self.inner.error as &dyn Any).downcast_ref::<T>().unwrap()
    }
}

impl<E: TypeSet> fmt::Debug for ErrorUnion<E> {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        Report::new(self).debug(formatter)
    }
}

impl<E: TypeSet> fmt::Display for ErrorUnion<E> {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        Report::new(self).display(formatter)
    }
}

//************************************************************************//

#[cfg(feature = "std")]
fn _send_sync_error_assert() {
    use std::io;

    fn is_send<T: Send>(_: &T) {}
    fn is_sync<T: Sync>(_: &T) {}
    fn is_error<T: core::error::Error>(_: &T) {}

    let error_union: ErrorUnion<(io::Error, fmt::Error)> =
        ErrorUnion::new(io::Error::other("yooo"));
    is_send(&error_union);
    is_sync(&error_union);
    // is_error(&error_union); //todo
}

unsafe impl<T> Send for ErrorUnion<T> where T: TypeSet + Send {}
unsafe impl<T> Sync for ErrorUnion<T> where T: TypeSet + Sync {}

//************************************************************************//

impl ErrorUnion {
    /// Create a new `ErrorUnion`.
    #[cfg_attr(feature = "location", track_caller)]
    pub fn new<T, OutSet, Index>(t: T) -> ErrorUnion<OutSet>
    where
        T: SendSyncError,
        OutSet: TypeSet,
        OutSet::Variants: Contains<T, Index>,
    {
        ErrorUnion {
            inner: ErrorUnionInner::new(t),
            _pd: PhantomData,
        }
    }

    #[allow(unused)] // Used with anyhow feature
    pub(crate) fn new_from_parts<T, OutSet, Index>(
        t: T,
        #[cfg(feature = "backtrace")] backtrace: std::backtrace::Backtrace,
        #[cfg(feature = "context")] context: Vec<ContextFrame>,
        #[cfg(feature = "location")] location: &'static core::panic::Location<'static>,
    ) -> ErrorUnion<OutSet>
    where
        T: SendSyncError,
        OutSet: TypeSet,
        OutSet::Variants: Contains<T, Index>,
    {
        ErrorUnion {
            inner: ErrorUnionInner::new_from_parts(
                t,
                #[cfg(feature = "backtrace")]
                backtrace,
                #[cfg(feature = "context")]
                context,
                #[cfg(feature = "location")]
                location,
            ),
            _pd: PhantomData,
        }
    }

    pub(crate) fn erase<E>(t: ErrorUnion<E>) -> ErrorUnion
    where
        E: TypeSet,
    {
        ErrorUnion {
            inner: t.inner,
            _pd: PhantomData,
        }
    }
}

//************************************************************************//

/// An [`ErrorUnion`] adapter implementing [`core::error::Error`].
///
/// Created by [`ErrorUnion::into_std_error`] without allocating or discarding
/// context, location, or backtrace.
///
/// ```
/// fn load() -> Result<(), eros::StdError> {
///     let result: eros::Result<()> = Err(eros::error!("missing configuration"));
///     result.map_err(eros::ErrorUnion::into_std_error)
/// }
///
/// fn accepts_error(_: impl core::error::Error + Send + Sync + 'static) {}
/// accepts_error(load().unwrap_err());
/// ```
pub struct StdError<E = AnyError>(ErrorUnion<E>)
where
    E: TypeSet;

impl<E: TypeSet> StdError<E> {
    /// Borrows the original union, including its diagnostics.
    pub fn as_union(&self) -> &ErrorUnion<E> {
        &self.0
    }

    /// Recovers the original union without allocating or discarding diagnostics.
    pub fn into_union(self) -> ErrorUnion<E> {
        self.0
    }
}

impl<E> core::error::Error for StdError<E>
where
    E: TypeSet,
{
    fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
        self.0.source()
    }
}

impl<E> fmt::Display for StdError<E>
where
    E: TypeSet,
{
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        // Native Error reporters traverse source() separately.
        write!(formatter, "{}", self.0.inner())
    }
}

impl<E> fmt::Debug for StdError<E>
where
    E: TypeSet,
{
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Debug::fmt(&self.0, formatter)
    }
}

impl<E> ErrorUnion<E>
where
    E: TypeSet,
{
    /// Adapts this union to [`core::error::Error`] without allocating.
    ///
    /// Preserves the error set, context, location, and backtrace. Use
    /// [`StdError::into_union`] to recover the original union.
    /// `ErrorUnion` cannot implement `Error` directly because its blanket
    /// conversion implementations would conflict.
    pub fn into_std_error(self) -> StdError<E> {
        StdError(self)
    }

    /// Recovers a union from a boxed [`StdError`] adapter.
    ///
    /// Returns the original boxed error unchanged if it is not an Eros adapter
    /// for the same error set `E`.
    ///
    /// ```
    /// use eros::{ErrorUnion, SendSyncError};
    /// # extern crate alloc;
    /// use alloc::boxed::Box;
    ///
    /// let error = eros::error!("missing configuration");
    /// let boxed: Box<dyn SendSyncError> = Box::new(error.into_std_error());
    /// let error: ErrorUnion = ErrorUnion::try_from_dyn_error(boxed).unwrap();
    /// assert_eq!(error.to_string(), "missing configuration");
    /// ```
    pub fn try_from_dyn_error(
        error: Box<dyn SendSyncError>,
    ) -> Result<Self, Box<dyn SendSyncError>> {
        let error_ref = &*error as &dyn Any;
        if !error_ref.is::<StdError<E>>() {
            return Err(error);
        }
        let error = error as Box<dyn Any>;
        let adapter = error.downcast::<StdError<E>>().unwrap();
        Ok(adapter.into_union())
    }
}

//************************************************************************//

impl<E> ErrorUnion<E>
where
    E: TypeSet,
{
    /// Selects one error type or a group, returning the remaining error union
    /// when the stored error does not match.
    ///
    /// A bare target, `narrow::<T, _>()`, extracts `T`, discarding context,
    /// location, and backtrace on a match. A tuple target, `narrow::<(T,), _>()`
    /// or `narrow::<(A, B), _>()`, returns an `ErrorUnion` of the selected types
    /// and preserves all diagnostics. The remainder always retains its
    /// diagnostics and original type order; the selected union uses the target order.
    ///
    /// Specify the target explicitly; the return type alone cannot infer it.
    /// Tuple targets support 0–26 types. An empty target `()` always returns
    /// the original union in `Err`. On an erased union, `AnyError` selects the
    /// original union without extracting the marker as a concrete error.
    ///
    /// ```
    /// use eros::{ErrorUnion, MsgError};
    /// use std::{fmt, io};
    ///
    /// let error: ErrorUnion<(MsgError, fmt::Error, io::Error)> =
    ///     ErrorUnion::new(MsgError::from("permission denied"));
    /// let error = error.context("read configuration");
    /// let selected = error.narrow::<(io::Error, MsgError), _>().unwrap();
    /// // Select a single type while retaining its diagnostics.
    /// let selected = selected.narrow::<(MsgError,), _>().unwrap();
    /// // Extract the concrete error when its diagnostics are no longer needed.
    /// let message = selected.narrow::<MsgError, _>().unwrap();
    /// assert_eq!(message.as_str(), "permission denied");
    /// ```
    #[allow(clippy::type_complexity)]
    pub fn narrow<Target, Index>(
        self,
    ) -> Result<Target::Output, ErrorUnion<<Target::Remainder as TupleForm>::Tuple>>
    where
        Target: NarrowTarget<E, Index>,
    {
        Target::split(self)
    }

    /// Turns the `ErrorUnion` into a `ErrorUnion` with a set of variants
    /// which is a superset of the current one. This may also be
    /// the same set of variants, but in a different order.
    pub fn widen<Other, Index>(self) -> ErrorUnion<Other>
    where
        Other: TypeSet,
        Other::Variants: SupersetOf<E::Variants, Index>,
    {
        ErrorUnion {
            inner: self.inner,
            _pd: PhantomData,
        }
    }

    /// Extracts the inner error if its concrete type is `T`.
    ///
    /// On success, context, location, and backtrace are discarded. On failure,
    /// returns the original union unchanged, including its error set and metadata.
    /// This checks only the inner error, not its sources or contexts.
    ///
    /// ```
    /// let error = eros::error!("failure").context("read configuration");
    /// let error = error.downcast_inner::<std::fmt::Error>().unwrap_err();
    /// let message = error.downcast_inner::<eros::MsgError>().unwrap();
    /// assert_eq!(message.as_str(), "failure");
    /// ```
    pub fn downcast_inner<T: 'static>(self) -> Result<T, Self> {
        if self.inner.is_error::<T>() {
            // SAFETY: The concrete inner error type was checked above.
            Ok(unsafe { self.inner.downcast_error_unchecked::<T>() })
        } else {
            Err(self)
        }
    }

    pub fn downcast_inner_ref<T: 'static>(&self) -> Option<&T> {
        self.inner.downcast_error_ref()
    }

    pub fn downcast_inner_mut<T: 'static>(&mut self) -> Option<&mut T> {
        self.inner.downcast_error_mut()
    }

    /// Returns true if the inner error is of type `T`
    pub fn is_inner<T: 'static>(&self) -> bool {
        self.inner.is_error::<T>()
    }

    #[cfg(feature = "backtrace")]
    pub fn backtrace(&self) -> &std::backtrace::Backtrace {
        &self.inner.backtrace
    }

    /// Returns where the error was first wrapped in an Eros union.
    ///
    /// Reshaping and mapping retain this original location. 
    /// With the `context` feature, each context frame also
    /// exposes its attachment location.
    #[cfg(feature = "location")]
    pub fn location(&self) -> &'static core::panic::Location<'static> {
        self.inner.location
    }

    /// Borrows all context frames in attachment order (innermost first).
    ///
    /// Includes both ordinary and user-facing contexts, with their available
    /// metadata. Does not allocate or format values. Requires the `context` feature.
    /// Use [`ContextFrame::value`] to borrow each frame's message or error.
    ///
    /// ```
    /// let error = eros::error!("permission denied").context("read configuration");
    /// for frame in error.contexts() {
    ///     println!("{}", frame.value());
    ///     #[cfg(feature = "location")]
    ///     println!("  at {}", frame.location());
    /// }
    /// ```
    ///
    /// With the `user_context` feature, filter for user-facing frames:
    ///
    /// ```
    /// # #[cfg(feature = "user_context")]
    /// # {
    /// let error = eros::error!("permission denied")
    ///     .context("read configuration")
    ///     .user_context("Could not load your settings.");
    /// for frame in error.contexts().filter(|frame| frame.is_user_facing()) {
    ///     println!("{frame}");
    /// }
    /// # }
    /// ```
    #[cfg(feature = "context")]
    pub fn contexts(
        &self,
    ) -> impl DoubleEndedIterator<Item = &crate::ContextFrame> + ExactSizeIterator {
        self.inner.context.iter()
    }

    pub fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
        self.inner.error.source()
    }

    /// Returns a reference to the stored inner error.
    pub fn inner(&self) -> &dyn SendSyncError {
        &self.inner.error
    }

    /// Returns a mutable reference to the stored inner error.
    pub fn inner_mut(&mut self) -> &mut dyn SendSyncError {
        &mut self.inner.error
    }

    /// Extracts the boxed inner error, discarding context, location, and backtrace.
    ///
    /// Reuses the existing allocation when all three features are disabled.
    pub fn into_inner(self) -> Box<dyn SendSyncError> {
        let raw = Box::into_raw(self.inner);
        #[cfg(not(any(feature = "backtrace", feature = "context", feature = "location")))]
        // SAFETY: ErrorUnionInner is repr(transparent) without metadata, so the
        // error has the same address, size, and alignment as the allocation.
        // Projecting the field preserves its trait-object metadata. Ownership
        // transfers to the returned Box, including for zero-sized errors.
        unsafe {
            Box::from_raw(ptr::addr_of_mut!((*raw).error))
        }
        #[cfg(any(feature = "backtrace", feature = "context", feature = "location"))]
        unsafe {
            let into_box_fn = (*raw).into_box_fn;
            let error_ptr = ptr::addr_of_mut!((*raw).error);

            let boxed = (into_box_fn)(error_ptr);

            // Drop remaining fields, free the allocation (same pattern as downcast_error_unchecked)
            #[cfg(feature = "backtrace")]
            ptr::drop_in_place(ptr::addr_of_mut!((*raw).backtrace));
            #[cfg(feature = "context")]
            ptr::drop_in_place(ptr::addr_of_mut!((*raw).context));
            #[cfg(feature = "location")]
            ptr::drop_in_place(ptr::addr_of_mut!((*raw).location));

            let _dead: Box<mem::ManuallyDrop<ErrorUnionInner<dyn SendSyncError>>> =
                Box::from_raw(raw as *mut _);

            boxed
        }
    }

    /// Returns the most recently attached error-valued context.
    ///
    /// String contexts are ignored. Returns `None` if no error-valued context
    /// has been attached, or if the `context` feature is disabled. This does not
    /// search the inner error's source chain.
    ///
    /// To fall back to the inner error when no context error exists:
    ///
    /// ```
    /// let error = eros::error!("permission denied").context("read configuration");
    /// let latest = error.latest_context_error().unwrap_or_else(|| error.inner());
    /// assert_eq!(latest.to_string(), "permission denied");
    /// ```
    pub fn latest_context_error(&self) -> Option<&dyn SendSyncError> {
        #[cfg(feature = "context")]
        for context in self.inner.context.iter().rev() {
            if let Some(err) = context.context.as_error() {
                return Some(err);
            }
        }
        None
    }

    /// Converts the union into an owned enum for pattern matching.
    ///
    /// Context, location, and backtrace are discarded.
    pub fn into_enum(self) -> E::Enum
    where
        E::Enum: From<Self>,
    {
        E::Enum::from(self)
    }

    /// Borrows the inner error as an enum of references for pattern matching.
    pub fn as_enum<'a>(&'a self) -> E::RefEnum<'a>
    where
        E::RefEnum<'a>: From<&'a Self>,
    {
        E::RefEnum::from(self)
    }

    /// Borrows the inner error as an enum of mutable references for pattern matching.
    pub fn as_mut_enum<'a>(&'a mut self) -> E::MutEnum<'a>
    where
        E::MutEnum<'a>: From<&'a mut Self>,
    {
        E::MutEnum::from(self)
    }

    /// Adds additional context. This becomes a no-op if the `context` feature is disabled.
    #[allow(unused_mut)]
    #[allow(unused_variables)]
    #[cfg_attr(feature = "location", track_caller)]
    pub fn context<C: Into<ContextValue>>(mut self, context: C) -> Self {
        #[cfg(feature = "context")]
        self.inner
            .context
            .push(crate::context::ContextFrame::new(context.into()));
        self
    }

    /// Adds additional context that is user facing. This becomes a no-op if the `context` feature is disabled.
    #[cfg(feature = "user_context")]
    #[allow(unused_mut)]
    #[allow(unused_variables)]
    #[cfg_attr(feature = "location", track_caller)]
    pub fn user_context<C: Into<ContextValue>>(mut self, context: C) -> Self {
        #[cfg(feature = "context")]
        self.inner
            .context
            .push(crate::context::ContextFrame::new_user_facing(context.into()));
        self
    }

    /// Lazily adds additional context. This becomes a no-op if the `context` feature is disabled.
    #[allow(unused_mut)]
    #[allow(unused_variables)]
    #[cfg_attr(feature = "location", track_caller)]
    pub fn with_context<F, C: Into<ContextValue>>(mut self, f: F) -> Self
    where
        F: FnOnce() -> C,
    {
        #[cfg(feature = "context")]
        self.inner
            .context
            .push(crate::context::ContextFrame::new(f().into()));
        self
    }

    /// Lazily adds additional user facing context. This becomes a no-op if the `context` feature is disabled.
    #[cfg(feature = "user_context")]
    #[allow(unused_mut)]
    #[allow(unused_variables)]
    #[cfg_attr(feature = "location", track_caller)]
    pub fn with_user_context<F, C: Into<ContextValue>>(mut self, f: F) -> Self
    where
        F: FnOnce() -> C,
    {
        #[cfg(feature = "context")]
        self.inner
            .context
            .push(crate::context::ContextFrame::new_user_facing(f().into()));
        self
    }
}

impl<A: SendSyncError> AsRef<A> for ErrorUnion<(A,)> {
    fn as_ref(&self) -> &A {
        self.inner.downcast_error_ref().unwrap()
    }
}

impl<A: SendSyncError> AsMut<A> for ErrorUnion<(A,)> {
    fn as_mut(&mut self) -> &mut A {
        self.inner.downcast_error_mut().unwrap()
    }
}

impl<A: SendSyncError> ErrorUnion<(A,)> {
    /// Convert the inner type of an `ErrorUnion` with a single possible type to that type.
    ///
    /// Use `as_ref` or `as_mut` if you want to borrow the inner type instead of consuming the `ErrorUnion`.
    pub fn into_single(self) -> A {
        unsafe { self.inner.downcast_error_unchecked() }
    }

    /// Maps the single concrete inner error, preserving context, location, and backtrace.
    ///
    /// For unions with any number of variants, use [`Self::map_inner`] to map
    /// the boxed inner error instead.
    pub fn map_single<U, F>(self, f: F) -> ErrorUnion<(U,)>
    where
        U: SendSyncError,
        F: FnOnce(A) -> U,
    {
        // SAFETY: We know that the inner error is only of type A, so we can safely downcast it
        let inner = unsafe { self.inner.downcast_error_unchecked_with_parts::<A>() };
        ErrorUnion {
            inner: ErrorUnionInner::new_from_parts(
                f(inner.error),
                #[cfg(feature = "backtrace")]
                inner.backtrace,
                #[cfg(feature = "context")]
                inner.context,
                #[cfg(feature = "location")]
                inner.location,
            ),
            _pd: PhantomData,
        }
    }
}

//************************************************************************//

/// Reshapes error sets and handles specific error types directly on results.
pub trait ReshapeUnion<S, E>
where
    E: TypeSet,
{
    /// Turns the `ErrorUnion` into a `ErrorUnion` with a set of variants
    /// which is a superset of the current one. This may also be
    /// the same set of variants, but in a different order.
    fn widen<Other, Index>(self) -> Result<S, ErrorUnion<Other>>
    where
        Other: TypeSet,
        Other::Variants: SupersetOf<E::Variants, Index>;

    /// Selects a matching error or group, returning the original success value
    /// or the remaining error union in the outer `Err` branch otherwise.
    ///
    /// As with [`ErrorUnion::narrow`], `narrow::<T, _>()` extracts a concrete
    /// error and discards its diagnostics. Tuple targets such as `(T,)` or
    /// `(A, B)` return an `ErrorUnion` with its diagnostics. The remainder
    /// always retains its diagnostics. Specify the target explicitly.
    ///
    /// ```
    /// use eros::{ErrorUnion, MsgError, ReshapeUnion};
    ///
    /// let result: eros::Result<u8, (MsgError, std::fmt::Error)> =
    ///     Err(ErrorUnion::new(MsgError::from("failed")));
    /// match result.narrow::<(MsgError,), _>() {
    ///     Ok(error) => assert_eq!(error.as_str(), "failed"),
    ///     Err(Ok(value)) => println!("success: {value}"),
    ///     Err(Err(remainder)) => eprintln!("unhandled: {remainder}"),
    /// }
    /// ```
    #[allow(clippy::type_complexity)]
    fn narrow<Target, Index>(
        self,
    ) -> Result<
        Target::Output,
        Result<S, ErrorUnion<<Target::Remainder as TupleForm>::Tuple>>,
    >
    where
        Target: NarrowTarget<E, Index>;

    /// Handles one error type or a group, removing the handled types from the result.
    ///
    /// Calls `f` once on a matching error and returns its value as `Ok`. The
    /// handler receives a union of the selected types with the original context,
    /// location, and backtrace. Unhandled types retain their original order.
    ///
    /// Use `recover::<ErrorType, _>(...)` for one type or
    /// `recover::<(FirstError, SecondError), _>(...)` for a group of 2–26 types.
    /// Alternatively, infer the target from an annotated handler argument such as
    /// `|error: ErrorUnion<(FirstError, SecondError)>| ...`.
    ///
    /// ```
    /// use eros::{ErrorUnion, ReshapeUnion};
    /// use std::{io, num::ParseIntError};
    ///
    /// let result: eros::Result<u16, (io::Error, ParseIntError)> =
    ///     Err(ErrorUnion::new(io::Error::other("cannot read port")));
    /// let result: eros::Result<u16, (ParseIntError,)> =
    ///     result.recover(|error: ErrorUnion<(io::Error,)>| {
    ///         eprintln!("{error:?}; using port 8080");
    ///         8080
    ///     });
    /// assert_eq!(result.unwrap(), 8080);
    /// ```
    ///
    /// Handle all errors in a group with one callback:
    ///
    /// ```
    /// use eros::{ErrorUnion, ReshapeUnion};
    /// use std::{io, num::ParseIntError};
    ///
    /// let result: eros::Result<u16, (io::Error, ParseIntError)> =
    ///     Err(ErrorUnion::new(io::Error::other("cannot read port")));
    /// let port = result
    ///     .recover(|error: ErrorUnion<(io::Error, ParseIntError)>| {
    ///         eprintln!("{error:?}; using port 8080");
    ///         8080
    ///     })
    ///     .into_value();
    /// assert_eq!(port, 8080);
    /// ```
    #[allow(clippy::type_complexity)]
    fn recover<Target, Index>(
        self,
        f: impl RecoveryHandler<Target, E, Index, S>,
    ) -> Result<S, ErrorUnion<<Target::Remainder as TupleForm>::Tuple>>
    where
        Target: RecoveryTarget<E, Index>;

    /// Handles one error type or a group with a fallible fallback.
    ///
    /// The handler receives the matching error with its original context,
    /// location, and backtrace. Its result is returned unchanged, including any
    /// fallback error's diagnostics. The original error's diagnostics are not
    /// automatically attached to a new fallback error. Successful input values
    /// and unhandled errors pass through without calling the handler.
    ///
    /// `Other` is inferred from the destination or the handler's return type.
    /// It must contain every unhandled error type as well as the errors returned
    /// by the handler. Use `.union()` or `.widen()` inside the handler to convert
    /// a fallback result into that set. The handler may reintroduce handled types.
    /// Select a group with `|error: ErrorUnion<(FirstError, SecondError)>| ...`
    /// or `try_recover::<(FirstError, SecondError), Other, _, _>(...)`.
    /// As with [`Self::recover`], explicit single-type targets use the concrete
    /// error type, and groups use tuples of 2–26 types. The index parameters are inferred.
    ///
    /// ```
    /// use eros::{ErrorUnion, IntoUnion, ReshapeUnion};
    /// use std::{io, num::ParseIntError};
    ///
    /// let result: eros::Result<u16, (io::Error, ParseIntError)> =
    ///     Err(ErrorUnion::new(io::Error::other("cannot read port")));
    /// let result: eros::Result<u16, (ParseIntError,)> =
    ///     result.try_recover(|error: ErrorUnion<(io::Error,)>| {
    ///         eprintln!("{error:?}; parsing fallback port");
    ///         "8080".parse::<u16>().union()
    ///     });
    /// assert_eq!(result.unwrap(), 8080);
    /// ```
    fn try_recover<Target, Other, Index, OtherIndex>(
        self,
        f: impl RecoveryHandler<Target, E, Index, Result<S, ErrorUnion<Other>>>,
    ) -> Result<S, ErrorUnion<Other>>
    where
        Target: RecoveryTarget<E, Index>,
        Other: TypeSet,
        Other::Variants: SupersetOf<Target::Remainder, OtherIndex>;

    /// Extracts the success value once no possible error types remain.
    ///
    /// Only available for `eros::Result<S, ()>`. As opposed to `unwrap`,
    /// calling this method does not compile if an unhandled error type remains in the result's set.
    ///
    /// ```
    /// use eros::{ErrorUnion, MsgError, ReshapeUnion};
    ///
    /// let result: eros::Result<u16, (MsgError,)> =
    ///     Err(ErrorUnion::new(MsgError::from("missing port")));
    /// let port = result.recover::<MsgError, _>(|_| 8080).into_value();
    /// assert_eq!(port, 8080);
    /// ```
    fn into_value(self) -> S
    where
        E: TypeSet<Enum = core::convert::Infallible>;
}

impl<S, E> ReshapeUnion<S, E> for Result<S, ErrorUnion<E>>
where
    E: TypeSet,
{
    fn widen<Other, Index>(self) -> Result<S, ErrorUnion<Other>>
    where
        Other: TypeSet,
        Other::Variants: SupersetOf<E::Variants, Index>,
    {
        self.map_err(|e| e.widen())
    }

    fn narrow<Target, Index>(
        self,
    ) -> Result<
        Target::Output,
        Result<S, ErrorUnion<<Target::Remainder as TupleForm>::Tuple>>,
    >
    where
        Target: NarrowTarget<E, Index>,
    {
        match self {
            Ok(value) => Err(Ok(value)),
            Err(err) => match err.narrow::<Target, Index>() {
                Ok(value) => Ok(value),
                Err(err) => Err(Err(err)),
            },
        }
    }

    fn recover<Target, Index>(
        self,
        f: impl RecoveryHandler<Target, E, Index, S>,
    ) -> Result<S, ErrorUnion<<Target::Remainder as TupleForm>::Tuple>>
    where
        Target: RecoveryTarget<E, Index>,
    {
        match self {
            Ok(value) => Ok(value),
            Err(error) => match Target::split(error) {
                Ok(selected) => Ok(f(selected)),
                Err(remainder) => Err(remainder),
            },
        }
    }

    fn try_recover<Target, Other, Index, OtherIndex>(
        self,
        f: impl RecoveryHandler<Target, E, Index, Result<S, ErrorUnion<Other>>>,
    ) -> Result<S, ErrorUnion<Other>>
    where
        Target: RecoveryTarget<E, Index>,
        Other: TypeSet,
        Other::Variants: SupersetOf<Target::Remainder, OtherIndex>,
    {
        match self {
            Ok(value) => Ok(value),
            Err(error) => match Target::split(error) {
                Ok(selected) => f(selected),
                // Other contains every unhandled type. Retain the remainder's
                // allocation and diagnostics, changing only its type marker.
                Err(remainder) => Err(ErrorUnion {
                    inner: remainder.inner,
                    _pd: PhantomData,
                }),
            },
        }
    }

    fn into_value(self) -> S
    where
        E: TypeSet<Enum = core::convert::Infallible>,
    {
        match self {
            Ok(value) => value,
            // TypeSet is sealed, and only () has an Infallible enum. A union
            // with that empty set cannot be constructed through the safe API.
            Err(_) => unreachable!("an empty error set cannot contain an error"),
        }
    }
}

//************************************************************************//

pub trait IntoUnion<S, F> {
    /// Wraps the result's error in a union whose error set is inferred from the destination.
    fn union<Other, Index>(self) -> Result<S, ErrorUnion<Other>>
    where
        Other: TypeSet,
        Other::Variants: Contains<F, Index>;
}

impl<S, F: SendSyncError> IntoUnion<S, F> for Result<S, F> {
    #[cfg_attr(feature = "location", track_caller)]
    fn union<Other, Index>(self) -> Result<S, ErrorUnion<Other>>
    where
        Other: TypeSet,
        Other::Variants: Contains<F, Index>,
    {
        // Note: We use match so the call location gets passed through
        match self {
            Ok(value) => Ok(value),
            Err(err) => Err(ErrorUnion::new(err)),
        }
    }
}

pub trait IntoAnyUnion<S> {
    /// Converts the result's error into an [`ErrorUnion<AnyError>`].
    ///
    /// Existing unions retain their context, location, and backtrace.
    fn any_union(self) -> Result<S, ErrorUnion>;
}

impl<S, F: SendSyncError> IntoAnyUnion<S> for Result<S, F> {
    #[cfg_attr(feature = "location", track_caller)]
    fn any_union(self) -> Result<S, ErrorUnion> {
        match self {
            Ok(value) => Ok(value),
            Err(err) => Err(ErrorUnion::new(err)),
        }
    }
}

impl<S, E: TypeSet> IntoAnyUnion<S> for Result<S, ErrorUnion<E>> {
    fn any_union(self) -> Result<S, ErrorUnion> {
        self.map_err(|e| ErrorUnion::erase(e))
    }
}

// pub trait IntoUnion<S, F> {
//     /// Con `Err` to i
//     fn union<Other, Index>(self) -> Result<S, ErrorUnion<Other>>
//     where
//         Other: TypeSet,
//         Other::Variants: Contains<F, Index>;
// }

// impl<S, F1, F2> IntoUnion<S, F2> for Result<S, F1>
// where
//     F1: Into<F2> + SendSyncError, // `SendSyncError` is used to ensure it does not overlap with below
//     F2: SendSyncError,
// {
//     fn union<Other, Index>(self) -> Result<S, ErrorUnion<Other>>
//     where
//         Other: TypeSet,
//         Other::Variants: Contains<F2, Index>,
//     {
//         self.map_err(|e| ErrorUnion::new(e.into()))
//     }
// }

// pub trait InnerInto<S, F> {
//     /// Converts the inner type of an `ErrorUnion` into another type
//     fn inner_into(self) -> Result<S, ErrorUnion<(F,)>>;
// }

// impl<S, F1, F2> InnerInto<S, F2> for Result<S, ErrorUnion<(F1,)>>
// where
//     F1: Into<F2> + SendSyncError,
//     F2: SendSyncError,
// {
//     fn inner_into(self) -> Result<S, ErrorUnion<(F2,)>> {
//         self.map_err(|e| e.map_single(|e| e.into()))
//     }
// }

// Commented out since it conflicts with the above and cant merge into one trait since the return type is attached to the method generic
// pub trait IntoUnion<F>
// where
//     F: AnyError,
// {
//     fn union<Other, Index>(self) -> ErrorUnion<Other>
//     where
//         Other: TypeSet,
//         // Other::Variants: SupersetOf<Cons<F, End>, Index>,
//         Other::Variants: Contains<F, Index>;
// }

// impl<F> IntoUnion<F> for F
// where
//     F: AnyError,
// {
//     fn union<Other, Index>(self) -> ErrorUnion<Other>
//     where
//         Other: TypeSet,
//         // Other::Variants: SupersetOf<Cons<F, End>, Index>,
//         Other::Variants: Contains<F, Index>,
//     {
//         ErrorUnion::new(self)
//     }
// }

//************************************************************************//

// anyhow::Error does not implement `core::error::Error` so we need to wrap it
#[cfg(feature = "anyhow")]
#[derive(Debug)]
pub(crate) struct AnyhowError(pub(crate) anyhow::Error);

#[cfg(feature = "anyhow")]
impl fmt::Display for AnyhowError {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(fmt, "{}", self.0)
    }
}

#[cfg(feature = "anyhow")]
impl core::error::Error for AnyhowError {
    fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
        self.0.source()
    }
}

#[cfg(feature = "anyhow")]
#[derive(Debug)]
pub(crate) struct AnyhowErrorArc(pub(crate) alloc::sync::Arc<anyhow::Error>);

#[cfg(feature = "anyhow")]
impl fmt::Display for AnyhowErrorArc {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(fmt, "{}", self.0)
    }
}

#[cfg(feature = "anyhow")]
impl core::error::Error for AnyhowErrorArc {
    fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
        self.0.source()
    }
}

#[cfg(feature = "anyhow")]
impl ErrorUnion {
    #[cfg_attr(feature = "location", track_caller)]
    pub fn from_anyhow(error: anyhow::Error) -> ErrorUnion {
        ErrorUnion::new_from_parts(
            AnyhowError(error),
            #[cfg(feature = "backtrace")]
            std::backtrace::Backtrace::disabled(),
            #[cfg(feature = "context")]
            Vec::new(),
            #[cfg(feature = "location")]
            core::panic::Location::caller(),
        )
    }

    #[cfg_attr(feature = "location", track_caller)]
    pub fn from_anyhow_arc(error: alloc::sync::Arc<anyhow::Error>) -> ErrorUnion {
        ErrorUnion::new_from_parts(
            AnyhowErrorArc(error),
            #[cfg(feature = "backtrace")]
            std::backtrace::Backtrace::disabled(),
            #[cfg(feature = "context")]
            Vec::new(),
            #[cfg(feature = "location")]
            core::panic::Location::caller(),
        )
    }
}

// Needs specialization
// impl From<anyhow::Error> for ErrorUnion {
//     fn from(value: anyhow::Error) -> Self {
//         ErrorUnion::from_anyhow(value)
//     }
// }

#[cfg(feature = "anyhow")]
impl From<ErrorUnion> for anyhow::Error {
    #[allow(unused_mut)]
    fn from(mut value: ErrorUnion) -> Self {
        #[cfg(feature = "context")]
        let context = core::mem::take(&mut value.inner.context);
        let inner_error = value.into_inner();
        let mut error = anyhow::Error::new(inner_error);
        #[cfg(feature = "context")]
        for c in context {
            error = error.context(c.context);
        }
        error
    }
}

//************************************************************************//

#[cfg(test)]
mod tests {
    use super::*;
    use std::fmt;
    #[cfg(not(feature = "std"))]
    use std::{prelude::v1::*, vec};

    //************************************************************************//

    #[derive(Debug, PartialEq)]
    struct FooError(String);

    impl fmt::Display for FooError {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            write!(f, "FooError({})", self.0)
        }
    }
    impl std::error::Error for FooError {}

    #[derive(Debug, PartialEq)]
    struct BarError(u32);

    impl fmt::Display for BarError {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            write!(f, "BarError({})", self.0)
        }
    }
    impl std::error::Error for BarError {}

    #[cfg(not(any(feature = "backtrace", feature = "context", feature = "location")))]
    #[test]
    fn inner_without_metadata_has_the_error_layout() {
        fn check<T: SendSyncError>(error: T) {
            assert_eq!(
                core::alloc::Layout::new::<ErrorUnionInner<T>>(),
                core::alloc::Layout::new::<T>()
            );
            let inner = ErrorUnionInner::new(error);
            assert_eq!(
                core::alloc::Layout::for_value(&*inner),
                core::alloc::Layout::for_value(&inner.error)
            );
        }

        check(FooError("owned".into()));
        check(BarError(42));
        check(fmt::Error);
    }

    #[test]
    fn downcast_error_unchecked_correct_type_recovers_value() {
        let inner = ErrorUnionInner::new(FooError("hello".into()));
        assert!(inner.is_error::<FooError>());
        let recovered: FooError = unsafe { inner.downcast_error_unchecked() };
        assert_eq!(recovered, FooError("hello".into()));
    }

    #[test]
    fn downcast_error_unchecked_does_not_leak_or_double_drop() {
        let payload = vec![1u8, 2, 3, 4, 5];

        #[derive(Debug, PartialEq)]
        struct VecError(Vec<u8>);
        impl fmt::Display for VecError {
            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                write!(f, "{:?}", self.0)
            }
        }
        impl std::error::Error for VecError {}

        let inner = ErrorUnionInner::new(VecError(payload.clone()));
        let recovered: VecError = unsafe { inner.downcast_error_unchecked() };
        assert_eq!(recovered.0, payload);
    }

    #[test]
    fn downcast_error_unchecked_with_parts_preserves_context() {
        let inner = ErrorUnionInner::new(FooError("ctx".into()));

        let mut union: ErrorUnion<(FooError,)> = ErrorUnion {
            inner,
            _pd: PhantomData,
        };

        #[cfg(feature = "context")]
        {
            union
                .inner
                .context
                .push(ContextFrame::new("step one".into()));
            union
                .inner
                .context
                .push(ContextFrame::new("step two".into()));
        }

        let parts: ErrorUnionInner<FooError> =
            unsafe { union.inner.downcast_error_unchecked_with_parts() };

        assert_eq!(parts.error, FooError("ctx".into()));

        #[cfg(feature = "context")]
        assert_eq!(parts.context.len(), 2);
    }

    #[test]
    fn downcast_error_unchecked_with_parts_correct_error_value() {
        let inner = ErrorUnionInner::new(BarError(42));
        let parts: ErrorUnionInner<BarError> =
            unsafe { inner.downcast_error_unchecked_with_parts() };
        assert_eq!(parts.error, BarError(42));
    }

    #[test]
    fn boxed_std_error_and_back_roundtrips() {
        let union: ErrorUnion<(FooError,)> = ErrorUnion::new(FooError("roundtrip".into()));
        let dyn_err: Box<dyn SendSyncError> = Box::new(union.into_std_error());
        assert!((&*dyn_err as &dyn Any).is::<StdError<(FooError,)>>());
        let recovered: ErrorUnion<(FooError,)> =
            ErrorUnion::try_from_dyn_error(dyn_err).expect("round-trip should succeed");

        assert_eq!(recovered.as_ref(), &FooError("roundtrip".into()));
    }

    #[test]
    fn try_from_dyn_error_wrong_type_returns_err() {
        let union: ErrorUnion<(FooError,)> = ErrorUnion::new(FooError("mismatch".into()));
        let dyn_err: Box<dyn SendSyncError> = Box::new(union.into_std_error());

        let result: Result<ErrorUnion<(BarError,)>, _> = ErrorUnion::try_from_dyn_error(dyn_err);
        assert!(result.is_err(), "mismatched type should be returned as Err");
    }

    #[test]
    fn std_error_display_delegates_to_inner() {
        let union: ErrorUnion<(FooError,)> = ErrorUnion::new(FooError("display".into()));
        let adapter = union.into_std_error();
        assert!(adapter.to_string().contains("FooError(display)"));
    }

    #[test]
    fn std_error_is_send_and_sync() {
        fn assert_send_sync<T: Send + Sync>(_: T) {}
        let union: ErrorUnion<(FooError,)> = ErrorUnion::new(FooError("traits".into()));
        assert_send_sync(union.into_std_error());
    }

    #[test]
    fn try_from_dyn_error_preserves_context() {
        let mut union: ErrorUnion<(FooError,)> = ErrorUnion::new(FooError("ctx".into()));
        #[cfg(feature = "context")]
        {
            union = union.context("some context");
        }
        let dyn_err = Box::new(union.into_std_error());
        let recovered: ErrorUnion<(FooError,)> = ErrorUnion::try_from_dyn_error(dyn_err).unwrap();

        #[cfg(feature = "context")]
        assert_eq!(recovered.inner.context.len(), 1);

        assert_eq!(recovered.as_ref(), &FooError("ctx".into()));
    }

    #[test]
    fn multi_variant_union_boxed_std_error_roundtrips() {
        let union: ErrorUnion<(FooError, BarError)> = ErrorUnion::new(BarError(99));
        let dyn_err = Box::new(union.into_std_error());

        let recovered: ErrorUnion<(FooError, BarError)> =
            ErrorUnion::try_from_dyn_error(dyn_err).unwrap();

        let bar: BarError = recovered.narrow::<BarError, _>().unwrap();
        assert_eq!(bar, BarError(99));
    }

    #[test]
    fn into_inner_dyn_error_returns_concrete_type_not_wrapper() {
        let union: ErrorUnion<(FooError,)> = ErrorUnion::new(FooError("concrete".into()));
        let dyn_err = union.into_inner();

        assert!(
            (&*dyn_err as &dyn Any).is::<FooError>(),
            "expected FooError, got a wrapper or wrong type"
        );
    }

    #[test]
    fn into_inner_dyn_error_value_is_preserved() {
        let union: ErrorUnion<(FooError,)> = ErrorUnion::new(FooError("preserved".into()));
        let dyn_err = union.into_inner();

        let foo = (&*dyn_err as &dyn Any).downcast_ref::<FooError>().unwrap();
        assert_eq!(foo, &FooError("preserved".into()));
    }

    #[test]
    fn into_inner_dyn_error_display_is_concrete_type() {
        let union: ErrorUnion<(FooError,)> = ErrorUnion::new(FooError("display".into()));
        let dyn_err = union.into_inner();

        assert_eq!(dyn_err.to_string(), "FooError(display)");
    }

    #[test]
    fn into_inner_dyn_error_is_send_and_sync() {
        fn assert_send_sync<T: Send + Sync>(_: T) {}
        let union: ErrorUnion<(FooError,)> = ErrorUnion::new(FooError("traits".into()));
        assert_send_sync(union.into_inner());
    }

    #[test]
    fn into_inner_differs_from_boxed_std_error() {
        let union_a: ErrorUnion<(FooError,)> = ErrorUnion::new(FooError("a".into()));
        let union_b: ErrorUnion<(FooError,)> = ErrorUnion::new(FooError("b".into()));

        let inner_dyn = union_a.into_inner();
        let wrapper_dyn = Box::new(union_b.into_std_error());

        assert!((&*inner_dyn as &dyn Any).is::<FooError>());
        assert!(!(&*wrapper_dyn as &dyn Any).is::<FooError>());
        assert!((&*wrapper_dyn as &dyn Any).is::<StdError<(FooError,)>>());
    }

    #[test]
    fn into_inner_dyn_error_multi_variant_foo() {
        let union: ErrorUnion<(FooError, BarError)> = ErrorUnion::new(FooError("multi".into()));
        let dyn_err = union.into_inner();

        assert!((&*dyn_err as &dyn Any).is::<FooError>());
        assert!(!(&*dyn_err as &dyn Any).is::<BarError>());
        let foo = (&*dyn_err as &dyn Any).downcast_ref::<FooError>().unwrap();
        assert_eq!(foo, &FooError("multi".into()));
    }

    #[test]
    fn into_inner_dyn_error_multi_variant_bar() {
        let union: ErrorUnion<(FooError, BarError)> = ErrorUnion::new(BarError(77));
        let dyn_err = union.into_inner();

        assert!((&*dyn_err as &dyn Any).is::<BarError>());
        assert!(!(&*dyn_err as &dyn Any).is::<FooError>());
        let bar = (&*dyn_err as &dyn Any).downcast_ref::<BarError>().unwrap();
        assert_eq!(bar, &BarError(77));
    }

    #[test]
    fn into_inner_dyn_error_does_not_leak_heap_allocation() {
        // Uses a Vec payload so Miri / address-sanitizer can catch leaks or double-drops.
        #[derive(Debug, PartialEq)]
        struct VecError(Vec<u8>);
        impl fmt::Display for VecError {
            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                write!(f, "{:?}", self.0)
            }
        }
        impl std::error::Error for VecError {}

        let payload = vec![1u8, 2, 3, 4, 5];
        let union: ErrorUnion<(VecError,)> = ErrorUnion::new(VecError(payload.clone()));
        let dyn_err = union.into_inner();

        let recovered = (&*dyn_err as &dyn Any).downcast_ref::<VecError>().unwrap();
        assert_eq!(recovered.0, payload);
        // `dyn_err` drops here — Miri will catch any double-free or leak.
    }

    #[test]
    fn into_inner_dyn_error_not_roundtrippable_via_try_from_dyn_error() {
        // Confirm that try_from_dyn_error correctly rejects a bare inner error
        // (since it's not wrapped in StdError).
        let union_a: ErrorUnion<(FooError,)> = ErrorUnion::new(FooError("bare".into()));
        let bare_dyn = union_a.into_inner();

        let result: Result<ErrorUnion<(FooError,)>, _> = ErrorUnion::try_from_dyn_error(bare_dyn);
        assert!(
            result.is_err(),
            "try_from_dyn_error should reject a bare inner error, not a StdError"
        );
    }
}

#[cfg(test)]
mod latest_context_error_tests {
    use super::*;
    use std::fmt;
    #[cfg(not(feature = "std"))]
    use std::prelude::v1::*;

    #[derive(Debug, PartialEq)]
    struct PrimaryError(String);
    impl fmt::Display for PrimaryError {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            write!(f, "PrimaryError({})", self.0)
        }
    }
    impl std::error::Error for PrimaryError {}

    #[derive(Debug, PartialEq)]
    struct ContextError(String);
    impl fmt::Display for ContextError {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            write!(f, "ContextError({})", self.0)
        }
    }
    impl std::error::Error for ContextError {}

    fn box_err(e: impl SendSyncError) -> Box<dyn SendSyncError> {
        Box::new(e)
    }

    #[test]
    fn latest_context_error_with_no_context_returns_none() {
        let union: ErrorUnion<(PrimaryError,)> = ErrorUnion::new(PrimaryError("base".into()));

        assert!(union.latest_context_error().is_none());
    }

    #[test]
    fn latest_context_error_fallback_returns_inner() {
        let union: ErrorUnion<(PrimaryError,)> = ErrorUnion::new(PrimaryError("base".into()));

        let error = union
            .latest_context_error()
            .unwrap_or_else(|| union.inner());
        assert_eq!(error.to_string(), "PrimaryError(base)");
        assert!(error.as_any().is::<PrimaryError>());
    }

    #[cfg(feature = "context")]
    #[test]
    fn latest_context_error_with_string_context_only_returns_none() {
        let union: ErrorUnion<(PrimaryError,)> = ErrorUnion::new(PrimaryError("base".into()));
        let union = union.context("just a string message");

        assert!(union.latest_context_error().is_none());
    }

    #[cfg(feature = "context")]
    #[test]
    fn latest_context_error_with_error_context_returns_context_error() {
        let union: ErrorUnion<(PrimaryError,)> = ErrorUnion::new(PrimaryError("base".into()));
        let union = union.context(box_err(ContextError("ctx-1".into())));

        assert_eq!(
            union.latest_context_error().unwrap().to_string(),
            "ContextError(ctx-1)"
        );
    }

    #[cfg(feature = "context")]
    #[test]
    fn latest_context_error_returns_most_recently_added_error_context() {
        let union: ErrorUnion<(PrimaryError,)> = ErrorUnion::new(PrimaryError("base".into()));
        let union = union
            .context(box_err(ContextError("ctx-1".into())))
            .context(box_err(ContextError("ctx-2".into())))
            .context(box_err(ContextError("ctx-3".into())));

        assert_eq!(
            union.latest_context_error().unwrap().to_string(),
            "ContextError(ctx-3)"
        );
    }

    #[cfg(feature = "context")]
    #[test]
    fn latest_context_error_skips_trailing_string_contexts_to_find_error_context() {
        let union: ErrorUnion<(PrimaryError,)> = ErrorUnion::new(PrimaryError("base".into()));
        let union = union
            .context(box_err(ContextError("ctx-1".into())))
            .context("a string note added after");

        assert_eq!(
            union.latest_context_error().unwrap().to_string(),
            "ContextError(ctx-1)"
        );
    }

    #[cfg(feature = "context")]
    #[test]
    fn latest_context_error_with_only_string_contexts_can_fall_back_to_inner() {
        let union: ErrorUnion<(PrimaryError,)> = ErrorUnion::new(PrimaryError("base".into()));
        let union = union.context("note one").context("note two");

        assert!(union.latest_context_error().is_none());
        let error = union
            .latest_context_error()
            .unwrap_or_else(|| union.inner());
        assert_eq!(error.to_string(), "PrimaryError(base)");
    }

    #[cfg(feature = "context")]
    #[test]
    fn latest_context_error_error_context_correct_concrete_type() {
        let union: ErrorUnion<(PrimaryError,)> = ErrorUnion::new(PrimaryError("base".into()));
        let union = union.context(box_err(ContextError("typed".into())));

        assert!(
            union
                .latest_context_error()
                .unwrap()
                .as_any()
                .is::<ContextError>()
        );
    }

    #[cfg(feature = "context")]
    #[test]
    fn latest_context_error_multi_variant_union_with_error_context() {
        let union: ErrorUnion<(PrimaryError, ContextError)> =
            ErrorUnion::new(PrimaryError("base".into()));
        let union = union.context(box_err(ContextError("ctx-1".into())));

        assert_eq!(
            union.latest_context_error().unwrap().to_string(),
            "ContextError(ctx-1)"
        );
    }
}

#[cfg(test)]
mod downcast_inner_tests {
    use super::*;
    use std::fmt;
    #[cfg(not(feature = "std"))]
    use std::{prelude::v1::*, vec};

    #[derive(Debug, PartialEq)]
    struct FooError(String);
    impl fmt::Display for FooError {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            write!(f, "FooError({})", self.0)
        }
    }
    impl std::error::Error for FooError {}

    #[derive(Debug, PartialEq)]
    struct BarError(u32);
    impl fmt::Display for BarError {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            write!(f, "BarError({})", self.0)
        }
    }
    impl std::error::Error for BarError {}

    #[test]
    fn downcast_inner_correct_type_returns_ok() {
        let union: ErrorUnion<(FooError,)> = ErrorUnion::new(FooError("hello".into()));
        let result = union.downcast_inner::<FooError>();
        assert_eq!(result.unwrap(), FooError("hello".into()));
    }

    #[test]
    fn downcast_inner_wrong_type_returns_original_union() {
        let union: ErrorUnion<(FooError, BarError)> = ErrorUnion::new(FooError("hello".into()));
        let result = union.downcast_inner::<BarError>();
        let union: ErrorUnion<(FooError, BarError)> = result.unwrap_err();
        assert_eq!(
            union.downcast_inner::<FooError>().unwrap(),
            FooError("hello".into())
        );
    }

    #[test]
    fn downcast_inner_multi_variant_correct_type() {
        let union: ErrorUnion<(FooError, BarError)> = ErrorUnion::new(BarError(7));
        let result = union.downcast_inner::<BarError>();
        assert_eq!(result.unwrap(), BarError(7));
    }

    #[test]
    fn downcast_inner_does_not_leak_or_double_drop() {
        // Vec payload lets Miri/ASan catch leaks or double-frees.
        #[derive(Debug, PartialEq)]
        struct VecError(Vec<u8>);
        impl fmt::Display for VecError {
            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                write!(f, "{:?}", self.0)
            }
        }
        impl std::error::Error for VecError {}

        let payload = vec![1u8, 2, 3, 4, 5];
        let union: ErrorUnion<(VecError,)> = ErrorUnion::new(VecError(payload.clone()));
        let result = union.downcast_inner::<VecError>();
        assert_eq!(result.unwrap(), VecError(payload));
    }

    #[test]
    fn downcast_inner_wrong_type_retains_value_without_leaking() {
        #[derive(Debug, PartialEq)]
        struct VecError(Vec<u8>);
        impl fmt::Display for VecError {
            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                write!(f, "{:?}", self.0)
            }
        }
        impl std::error::Error for VecError {}

        let union: ErrorUnion<(VecError, FooError)> = ErrorUnion::new(VecError(vec![9, 9, 9]));
        let result = union.downcast_inner::<FooError>();
        let union = result.unwrap_err();
        assert_eq!(
            union.downcast_inner::<VecError>().unwrap(),
            VecError(vec![9, 9, 9])
        );
    }

    #[test]
    fn downcast_inner_ref_correct_type_returns_some() {
        let union: ErrorUnion<(FooError,)> = ErrorUnion::new(FooError("ref".into()));
        let result = union.downcast_inner_ref::<FooError>();
        assert_eq!(result, Some(&FooError("ref".into())));
    }

    #[test]
    fn downcast_inner_ref_wrong_type_returns_none() {
        let union: ErrorUnion<(FooError, BarError)> = ErrorUnion::new(FooError("ref".into()));
        let result = union.downcast_inner_ref::<BarError>();
        assert_eq!(result, None);
    }

    #[test]
    fn downcast_inner_ref_does_not_consume_union() {
        let union: ErrorUnion<(FooError,)> = ErrorUnion::new(FooError("still here".into()));
        let first = union.downcast_inner_ref::<FooError>();
        assert_eq!(first, Some(&FooError("still here".into())));
        // Union is still usable afterwards since this took `&self`.
        let second = union.downcast_inner_ref::<FooError>();
        assert_eq!(second, Some(&FooError("still here".into())));
    }

    #[test]
    fn downcast_inner_ref_multi_variant_bar() {
        let union: ErrorUnion<(FooError, BarError)> = ErrorUnion::new(BarError(123));
        assert_eq!(union.downcast_inner_ref::<BarError>(), Some(&BarError(123)));
        assert_eq!(union.downcast_inner_ref::<FooError>(), None);
    }

    #[test]
    fn downcast_inner_mut_correct_type_returns_some() {
        let mut union: ErrorUnion<(FooError,)> = ErrorUnion::new(FooError("mut".into()));
        let result = union.downcast_inner_mut::<FooError>();
        assert_eq!(result, Some(&mut FooError("mut".into())));
    }

    #[test]
    fn downcast_inner_mut_wrong_type_returns_none() {
        let mut union: ErrorUnion<(FooError, BarError)> = ErrorUnion::new(FooError("mut".into()));
        let result = union.downcast_inner_mut::<BarError>();
        assert_eq!(result, None);
    }

    #[test]
    fn downcast_inner_mut_allows_mutation() {
        let mut union: ErrorUnion<(FooError,)> = ErrorUnion::new(FooError("before".into()));
        {
            let inner = union.downcast_inner_mut::<FooError>().unwrap();
            inner.0 = "after".into();
        }
        assert_eq!(
            union.downcast_inner_ref::<FooError>(),
            Some(&FooError("after".into()))
        );
    }

    #[test]
    fn downcast_inner_mut_multi_variant_bar() {
        let mut union: ErrorUnion<(FooError, BarError)> = ErrorUnion::new(BarError(1));
        {
            let bar = union.downcast_inner_mut::<BarError>().unwrap();
            bar.0 = 99;
        }
        assert_eq!(union.downcast_inner_ref::<BarError>(), Some(&BarError(99)));
        assert_eq!(union.downcast_inner_mut::<FooError>(), None);
    }
}