use core::any::TypeId;
use core::fmt::{self, Debug, Display};
use core::mem::ManuallyDrop;
use core::ptr::{self, NonNull};
use std::error::Error as StdError;
use super::ptr::{Mut, Own, Ref};
use super::Report;
use super::ReportHandler;
use crate::chain::Chain;
use crate::eyreish::wrapper::WithSourceCode;
use crate::{Diagnostic, SourceCode};
use core::ops::{Deref, DerefMut};
impl Report {
#[cfg_attr(track_caller, track_caller)]
pub fn new<E>(error: E) -> Self
where
E: Diagnostic + Send + Sync + 'static,
{
Report::from_std(error)
}
#[cfg_attr(track_caller, track_caller)]
pub fn msg<M>(message: M) -> Self
where
M: Display + Debug + Send + Sync + 'static,
{
Report::from_adhoc(message)
}
#[cfg_attr(track_caller, track_caller)]
pub fn new_boxed(error: Box<dyn Diagnostic + Send + Sync + 'static>) -> Self {
Report::from_boxed(error)
}
#[cfg_attr(track_caller, track_caller)]
pub(crate) fn from_std<E>(error: E) -> Self
where
E: Diagnostic + Send + Sync + 'static,
{
let vtable = &ErrorVTable {
object_drop: object_drop::<E>,
object_ref: object_ref::<E>,
object_ref_stderr: object_ref_stderr::<E>,
object_boxed: object_boxed::<E>,
object_boxed_stderr: object_boxed_stderr::<E>,
object_downcast: object_downcast::<E>,
object_drop_rest: object_drop_front::<E>,
};
let handler = Some(super::capture_handler(&error));
unsafe { Report::construct(error, vtable, handler) }
}
#[cfg_attr(track_caller, track_caller)]
pub(crate) fn from_adhoc<M>(message: M) -> Self
where
M: Display + Debug + Send + Sync + 'static,
{
use super::wrapper::MessageError;
let error: MessageError<M> = MessageError(message);
let vtable = &ErrorVTable {
object_drop: object_drop::<MessageError<M>>,
object_ref: object_ref::<MessageError<M>>,
object_ref_stderr: object_ref_stderr::<MessageError<M>>,
object_boxed: object_boxed::<MessageError<M>>,
object_boxed_stderr: object_boxed_stderr::<MessageError<M>>,
object_downcast: object_downcast::<M>,
object_drop_rest: object_drop_front::<M>,
};
let handler = Some(super::capture_handler(&error));
unsafe { Report::construct(error, vtable, handler) }
}
#[cfg_attr(track_caller, track_caller)]
pub(crate) fn from_msg<D, E>(msg: D, error: E) -> Self
where
D: Display + Send + Sync + 'static,
E: Diagnostic + Send + Sync + 'static,
{
let error: ContextError<D, E> = ContextError { msg, error };
let vtable = &ErrorVTable {
object_drop: object_drop::<ContextError<D, E>>,
object_ref: object_ref::<ContextError<D, E>>,
object_ref_stderr: object_ref_stderr::<ContextError<D, E>>,
object_boxed: object_boxed::<ContextError<D, E>>,
object_boxed_stderr: object_boxed_stderr::<ContextError<D, E>>,
object_downcast: context_downcast::<D, E>,
object_drop_rest: context_drop_rest::<D, E>,
};
let handler = Some(super::capture_handler(&error));
unsafe { Report::construct(error, vtable, handler) }
}
#[cfg_attr(track_caller, track_caller)]
pub(crate) fn from_boxed(error: Box<dyn Diagnostic + Send + Sync>) -> Self {
use super::wrapper::BoxedError;
let error = BoxedError(error);
let handler = Some(super::capture_handler(&error));
let vtable = &ErrorVTable {
object_drop: object_drop::<BoxedError>,
object_ref: object_ref::<BoxedError>,
object_ref_stderr: object_ref_stderr::<BoxedError>,
object_boxed: object_boxed::<BoxedError>,
object_boxed_stderr: object_boxed_stderr::<BoxedError>,
object_downcast: object_downcast::<Box<dyn Diagnostic + Send + Sync>>,
object_drop_rest: object_drop_front::<Box<dyn Diagnostic + Send + Sync>>,
};
unsafe { Report::construct(error, vtable, handler) }
}
unsafe fn construct<E>(
error: E,
vtable: &'static ErrorVTable,
handler: Option<Box<dyn ReportHandler>>,
) -> Self
where
E: Diagnostic + Send + Sync + 'static,
{
let inner = Box::new(ErrorImpl {
vtable,
handler,
_object: error,
});
let inner = Own::new(inner).cast::<ErasedErrorImpl>();
Report { inner }
}
pub fn wrap_err<D>(self, msg: D) -> Self
where
D: Display + Send + Sync + 'static,
{
let handler = unsafe { self.inner.by_mut().deref_mut().handler.take() };
let error: ContextError<D, Report> = ContextError { msg, error: self };
let vtable = &ErrorVTable {
object_drop: object_drop::<ContextError<D, Report>>,
object_ref: object_ref::<ContextError<D, Report>>,
object_ref_stderr: object_ref_stderr::<ContextError<D, Report>>,
object_boxed: object_boxed::<ContextError<D, Report>>,
object_boxed_stderr: object_boxed_stderr::<ContextError<D, Report>>,
object_downcast: context_chain_downcast::<D>,
object_drop_rest: context_chain_drop_rest::<D>,
};
unsafe { Report::construct(error, vtable, handler) }
}
pub fn context<D>(self, msg: D) -> Self
where
D: Display + Send + Sync + 'static,
{
self.wrap_err(msg)
}
pub fn chain(&self) -> Chain<'_> {
unsafe { ErrorImpl::chain(self.inner.by_ref()) }
}
pub fn root_cause(&self) -> &(dyn StdError + 'static) {
self.chain().last().unwrap()
}
pub fn is<E>(&self) -> bool
where
E: Display + Debug + Send + Sync + 'static,
{
self.downcast_ref::<E>().is_some()
}
pub fn downcast<E>(self) -> Result<E, Self>
where
E: Display + Debug + Send + Sync + 'static,
{
let target = TypeId::of::<E>();
let inner = self.inner.by_mut();
unsafe {
let addr = match (vtable(inner.ptr).object_downcast)(inner.by_ref(), target) {
Some(addr) => addr.by_mut().extend(),
None => return Err(self),
};
let outer = ManuallyDrop::new(self);
let error = addr.cast::<E>().read();
(vtable(outer.inner.ptr).object_drop_rest)(outer.inner, target);
Ok(error)
}
}
pub fn downcast_ref<E>(&self) -> Option<&E>
where
E: Display + Debug + Send + Sync + 'static,
{
let target = TypeId::of::<E>();
unsafe {
let addr = (vtable(self.inner.ptr).object_downcast)(self.inner.by_ref(), target)?;
Some(addr.cast::<E>().deref())
}
}
pub fn downcast_mut<E>(&mut self) -> Option<&mut E>
where
E: Display + Debug + Send + Sync + 'static,
{
let target = TypeId::of::<E>();
unsafe {
let addr =
(vtable(self.inner.ptr).object_downcast)(self.inner.by_ref(), target)?.by_mut();
Some(addr.cast::<E>().deref_mut())
}
}
pub fn handler(&self) -> &dyn ReportHandler {
unsafe {
self.inner
.by_ref()
.deref()
.handler
.as_ref()
.unwrap()
.as_ref()
}
}
pub fn handler_mut(&mut self) -> &mut dyn ReportHandler {
unsafe {
self.inner
.by_mut()
.deref_mut()
.handler
.as_mut()
.unwrap()
.as_mut()
}
}
pub fn with_source_code(self, source_code: impl SourceCode + Send + Sync + 'static) -> Report {
WithSourceCode {
source_code,
error: self,
}
.into()
}
}
impl<E> From<E> for Report
where
E: Diagnostic + Send + Sync + 'static,
{
#[cfg_attr(track_caller, track_caller)]
fn from(error: E) -> Self {
Report::from_std(error)
}
}
impl Deref for Report {
type Target = dyn Diagnostic + Send + Sync + 'static;
fn deref(&self) -> &Self::Target {
unsafe { ErrorImpl::diagnostic(self.inner.by_ref()) }
}
}
impl DerefMut for Report {
fn deref_mut(&mut self) -> &mut Self::Target {
unsafe { ErrorImpl::diagnostic_mut(self.inner.by_mut()) }
}
}
impl Display for Report {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
unsafe { ErrorImpl::display(self.inner.by_ref(), formatter) }
}
}
impl Debug for Report {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
unsafe { ErrorImpl::debug(self.inner.by_ref(), formatter) }
}
}
impl Drop for Report {
fn drop(&mut self) {
unsafe {
(vtable(self.inner.ptr).object_drop)(self.inner);
}
}
}
struct ErrorVTable {
object_drop: unsafe fn(Own<ErasedErrorImpl>),
object_ref:
unsafe fn(Ref<'_, ErasedErrorImpl>) -> Ref<'_, dyn Diagnostic + Send + Sync + 'static>,
object_ref_stderr:
unsafe fn(Ref<'_, ErasedErrorImpl>) -> Ref<'_, dyn StdError + Send + Sync + 'static>,
#[allow(clippy::type_complexity)]
object_boxed: unsafe fn(Own<ErasedErrorImpl>) -> Box<dyn Diagnostic + Send + Sync + 'static>,
#[allow(clippy::type_complexity)]
object_boxed_stderr:
unsafe fn(Own<ErasedErrorImpl>) -> Box<dyn StdError + Send + Sync + 'static>,
object_downcast: unsafe fn(Ref<'_, ErasedErrorImpl>, TypeId) -> Option<Ref<'_, ()>>,
object_drop_rest: unsafe fn(Own<ErasedErrorImpl>, TypeId),
}
unsafe fn object_drop<E>(e: Own<ErasedErrorImpl>) {
let unerased = e.cast::<ErrorImpl<E>>().boxed();
drop(unerased);
}
unsafe fn object_drop_front<E>(e: Own<ErasedErrorImpl>, target: TypeId) {
let _ = target;
let unerased = e.cast::<ErrorImpl<ManuallyDrop<E>>>().boxed();
drop(unerased);
}
unsafe fn object_ref<E>(
e: Ref<'_, ErasedErrorImpl>,
) -> Ref<'_, dyn Diagnostic + Send + Sync + 'static>
where
E: Diagnostic + Send + Sync + 'static,
{
let unerased = e.cast::<ErrorImpl<E>>();
Ref::from_raw(NonNull::new_unchecked(
ptr::addr_of!((*unerased.as_ptr())._object) as *mut E,
))
}
unsafe fn object_ref_stderr<E>(
e: Ref<'_, ErasedErrorImpl>,
) -> Ref<'_, dyn StdError + Send + Sync + 'static>
where
E: StdError + Send + Sync + 'static,
{
let unerased = e.cast::<ErrorImpl<E>>();
Ref::from_raw(NonNull::new_unchecked(
ptr::addr_of!((*unerased.as_ptr())._object) as *mut E,
))
}
unsafe fn object_boxed<E>(e: Own<ErasedErrorImpl>) -> Box<dyn Diagnostic + Send + Sync + 'static>
where
E: Diagnostic + Send + Sync + 'static,
{
e.cast::<ErrorImpl<E>>().boxed()
}
unsafe fn object_boxed_stderr<E>(
e: Own<ErasedErrorImpl>,
) -> Box<dyn StdError + Send + Sync + 'static>
where
E: StdError + Send + Sync + 'static,
{
e.cast::<ErrorImpl<E>>().boxed()
}
unsafe fn object_downcast<E>(e: Ref<'_, ErasedErrorImpl>, target: TypeId) -> Option<Ref<'_, ()>>
where
E: 'static,
{
if TypeId::of::<E>() == target {
let unerased = e.cast::<ErrorImpl<E>>();
Some(
Ref::from_raw(NonNull::new_unchecked(
ptr::addr_of!((*unerased.as_ptr())._object) as *mut E,
))
.cast::<()>(),
)
} else {
None
}
}
unsafe fn context_downcast<D, E>(e: Ref<'_, ErasedErrorImpl>, target: TypeId) -> Option<Ref<'_, ()>>
where
D: 'static,
E: 'static,
{
if TypeId::of::<D>() == target {
let unerased = e.cast::<ErrorImpl<ContextError<D, E>>>().deref();
Some(Ref::new(&unerased._object.msg).cast::<()>())
} else if TypeId::of::<E>() == target {
let unerased = e.cast::<ErrorImpl<ContextError<D, E>>>().deref();
Some(Ref::new(&unerased._object.error).cast::<()>())
} else {
None
}
}
unsafe fn context_drop_rest<D, E>(e: Own<ErasedErrorImpl>, target: TypeId)
where
D: 'static,
E: 'static,
{
if TypeId::of::<D>() == target {
let unerased = e
.cast::<ErrorImpl<ContextError<ManuallyDrop<D>, E>>>()
.boxed();
drop(unerased);
} else {
let unerased = e
.cast::<ErrorImpl<ContextError<D, ManuallyDrop<E>>>>()
.boxed();
drop(unerased);
}
}
unsafe fn context_chain_downcast<D>(
e: Ref<'_, ErasedErrorImpl>,
target: TypeId,
) -> Option<Ref<'_, ()>>
where
D: 'static,
{
let unerased = e.cast::<ErrorImpl<ContextError<D, Report>>>().deref();
if TypeId::of::<D>() == target {
Some(Ref::new(&unerased._object.msg).cast::<()>())
} else {
let source = &unerased._object.error;
(vtable(source.inner.ptr).object_downcast)(source.inner.by_ref(), target)
}
}
unsafe fn context_chain_drop_rest<D>(e: Own<ErasedErrorImpl>, target: TypeId)
where
D: 'static,
{
if TypeId::of::<D>() == target {
let unerased = e
.cast::<ErrorImpl<ContextError<ManuallyDrop<D>, Report>>>()
.boxed();
drop(unerased);
} else {
let unerased = e
.cast::<ErrorImpl<ContextError<D, ManuallyDrop<Report>>>>()
.boxed();
let inner = unerased._object.error.inner;
drop(unerased);
let vtable = vtable(inner.ptr);
(vtable.object_drop_rest)(inner, target);
}
}
#[repr(C)]
pub(crate) struct ErrorImpl<E> {
vtable: &'static ErrorVTable,
pub(crate) handler: Option<Box<dyn ReportHandler>>,
_object: E,
}
#[repr(C)]
pub(crate) struct ContextError<D, E> {
pub(crate) msg: D,
pub(crate) error: E,
}
type ErasedErrorImpl = ErrorImpl<()>;
unsafe fn vtable(p: NonNull<ErasedErrorImpl>) -> &'static ErrorVTable {
(p.as_ptr() as *const &'static ErrorVTable).read()
}
impl<E> ErrorImpl<E> {
fn erase(&self) -> Ref<'_, ErasedErrorImpl> {
Ref::new(self).cast::<ErasedErrorImpl>()
}
}
impl ErasedErrorImpl {
pub(crate) unsafe fn error<'a>(
this: Ref<'a, Self>,
) -> &'a (dyn StdError + Send + Sync + 'static) {
(vtable(this.ptr).object_ref_stderr)(this).deref()
}
pub(crate) unsafe fn diagnostic<'a>(
this: Ref<'a, Self>,
) -> &'a (dyn Diagnostic + Send + Sync + 'static) {
(vtable(this.ptr).object_ref)(this).deref()
}
pub(crate) unsafe fn diagnostic_mut<'a>(
this: Mut<'a, Self>,
) -> &'a mut (dyn Diagnostic + Send + Sync + 'static) {
(vtable(this.ptr).object_ref)(this.by_ref())
.by_mut()
.deref_mut()
}
pub(crate) unsafe fn chain(this: Ref<'_, Self>) -> Chain<'_> {
Chain::new(Self::error(this))
}
}
impl<E> StdError for ErrorImpl<E>
where
E: StdError,
{
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
unsafe { ErrorImpl::diagnostic(self.erase()).source() }
}
}
impl<E> Diagnostic for ErrorImpl<E> where E: Diagnostic {}
impl<E> Debug for ErrorImpl<E>
where
E: Debug,
{
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
unsafe { ErrorImpl::debug(self.erase(), formatter) }
}
}
impl<E> Display for ErrorImpl<E>
where
E: Display,
{
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
unsafe { Display::fmt(ErrorImpl::diagnostic(self.erase()), formatter) }
}
}
impl From<Report> for Box<dyn Diagnostic + Send + Sync + 'static> {
fn from(error: Report) -> Self {
let outer = ManuallyDrop::new(error);
unsafe {
(vtable(outer.inner.ptr).object_boxed)(outer.inner)
}
}
}
impl From<Report> for Box<dyn StdError + Send + Sync + 'static> {
fn from(error: Report) -> Self {
let outer = ManuallyDrop::new(error);
unsafe {
(vtable(outer.inner.ptr).object_boxed_stderr)(outer.inner)
}
}
}
impl From<Report> for Box<dyn Diagnostic + 'static> {
fn from(error: Report) -> Self {
Box::<dyn Diagnostic + Send + Sync>::from(error)
}
}
impl From<Report> for Box<dyn StdError + 'static> {
fn from(error: Report) -> Self {
Box::<dyn StdError + Send + Sync>::from(error)
}
}
impl AsRef<dyn Diagnostic + Send + Sync> for Report {
fn as_ref(&self) -> &(dyn Diagnostic + Send + Sync + 'static) {
&**self
}
}
impl AsRef<dyn Diagnostic> for Report {
fn as_ref(&self) -> &(dyn Diagnostic + 'static) {
&**self
}
}
impl AsRef<dyn StdError + Send + Sync> for Report {
fn as_ref(&self) -> &(dyn StdError + Send + Sync + 'static) {
unsafe { ErrorImpl::error(self.inner.by_ref()) }
}
}
impl AsRef<dyn StdError> for Report {
fn as_ref(&self) -> &(dyn StdError + 'static) {
unsafe { ErrorImpl::error(self.inner.by_ref()) }
}
}
impl std::borrow::Borrow<dyn Diagnostic> for Report {
fn borrow(&self) -> &(dyn Diagnostic + 'static) {
self.as_ref()
}
}