fatality based errors (#4448)

* seed commit for fatality based errors

* fatality

* first draft of fatality

* cleanup

* differnt approach

* simplify

* first working version for enums, with documentation

* add split

* fix simple split test case

* extend README.md

* update fatality impl

* make tests passed

* apply fatality to first subsystem

* fatality fixes

* use fatality in a subsystem

* fix subsystemg

* fixup proc macro

* fix/test: log::*! do not execute when log handler is missing

* fix spelling

* rename Runtime2 to something sane

* allow nested split with `forward` annotations

* add free license

* enable and fixup all tests

* use external fatality

Makes this more reviewable.

* bump fatality dep

Avoid duplicate expander compilations.

* migrate availability distribution

* more fatality usage

* chore: bump fatality to 0.0.6

* fixup remaining subsystems

* chore: fmt

* make cargo spellcheck happy

* remove single instance of `#[fatal(false)]`

* last quality sweep

* fixup

polkadot/node/network/dispute-distribution/src/error.rs

@@ -17,76 +17,54 @@
 
 //! Error handling related code and Error/Result definitions.
 
-use thiserror::Error;
-
 use polkadot_node_subsystem_util::runtime;
 use polkadot_subsystem::SubsystemError;
 
 use crate::{sender, LOG_TARGET};
 
-#[derive(Debug, Error, derive_more::From)]
-#[error(transparent)]
+use fatality::Nested;
+
+#[allow(missing_docs)]
+#[fatality::fatality(splitable)]
 pub enum Error {
-	/// Fatal errors of dispute distribution.
-	Fatal(Fatal),
-	/// Non-fatal errors of dispute distribution.
-	NonFatal(NonFatal),
-}
-
-impl From<sender::Error> for Error {
-	fn from(o: sender::Error) -> Self {
-		match o {
-			sender::Error::Fatal(f) => Self::Fatal(Fatal::Sender(f)),
-			sender::Error::NonFatal(f) => Self::NonFatal(NonFatal::Sender(f)),
-		}
-	}
-}
-
-/// Fatal errors of this subsystem.
-#[derive(Debug, Error)]
-pub enum Fatal {
 	/// Receiving subsystem message from overseer failed.
+	#[fatal]
 	#[error("Receiving message from overseer failed")]
 	SubsystemReceive(#[source] SubsystemError),
 
 	/// Spawning a running task failed.
+	#[fatal]
 	#[error("Spawning subsystem task failed")]
 	SpawnTask(#[source] SubsystemError),
 
 	/// `DisputeSender` mpsc receiver exhausted.
+	#[fatal]
 	#[error("Erasure chunk requester stream exhausted")]
 	SenderExhausted,
 
 	/// Errors coming from `runtime::Runtime`.
+	#[fatal(forward)]
 	#[error("Error while accessing runtime information")]
-	Runtime(#[from] runtime::Fatal),
+	Runtime(#[from] runtime::Error),
 
 	/// Errors coming from `DisputeSender`
+	#[fatal(forward)]
 	#[error("Error while accessing runtime information")]
-	Sender(#[from] sender::Fatal),
-}
-
-/// Non-fatal errors of this subsystem.
-#[derive(Debug, Error)]
-pub enum NonFatal {
-	/// Errors coming from `DisputeSender`
-	#[error("Error while accessing runtime information")]
-	Sender(#[from] sender::NonFatal),
+	Sender(#[from] sender::Error),
 }
 
 pub type Result<T> = std::result::Result<T, Error>;
 
-pub type FatalResult<T> = std::result::Result<T, Fatal>;
+pub type FatalResult<T> = std::result::Result<T, FatalError>;
 
 /// Utility for eating top level errors and log them.
 ///
 /// We basically always want to try and continue on error. This utility function is meant to
 /// consume top-level errors by simply logging them
-pub fn log_error(result: Result<()>, ctx: &'static str) -> std::result::Result<(), Fatal> {
-	match result {
-		Err(Error::Fatal(f)) => Err(f),
-		Err(Error::NonFatal(error)) => {
-			tracing::warn!(target: LOG_TARGET, error = ?error, ctx);
+pub fn log_error(result: Result<()>, ctx: &'static str) -> std::result::Result<(), FatalError> {
+	match result.into_nested()? {
+		Err(jfyi) => {
+			tracing::warn!(target: LOG_TARGET, error = ?jfyi, ctx);
 			Ok(())
 		},
 		Ok(()) => Ok(()),