Turning a Report that has been downcast to std::error::Error, back into a Report about color-eyre

[Mythra]

FWIW this is currently not possible, and while there is work ongoing in the meantime if someone runs into a similar error I got around this by not returning a Report (in the initial error that gets Into<Box<std::errror::Error>>), but instead returning a type I wrote which carries the report through without losing the context.

The type is the below:

pub struct EyreSpyASmuggler {
	inner: Report,
}

impl EyreSpyASmuggler {
	/// Construct a new temporary error holder.
	pub fn new(reportable: Report) -> Self {
		Self { inner: reportable }
	}

	/// Consume an error holder to get the report back out of it.
	pub fn consume(self) -> Report {
		self.inner
	}
}

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

impl std::fmt::Debug for EyreSpyASmuggler {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		write!(f, "{:?}", self.inner)
	}
}

impl std::error::Error for EyreSpyASmuggler {
	fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
		None
	}
}

This prints out exactly like a report would incase someone forgets to unwrap it, or use it directly. However in the case mentioned above I can just consume it, and use it like so. The code originally producing the error looks like this:

let resp = other_conn.call(req).await;
if let Err(resp_err) = resp {
  return Err(EyreSpyASmuggler::new(tcp_stream_to_eyre(resp_err)));
}
Ok(EtherStream::Tcp(resp.unwrap()))

Then when handling it, to get the report back I simply downcast, and consume:

if cause.is::<EyreSpyASmuggler>() {
  let as_report: Report = cause.downcast::<EyreSpyASmuggler>().unwrap().consume();
  // ... Do stuff with report.
} else {
  eyre!("Unknown Cause!")
}