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/subsystem-util/src/runtime/error.rs

@@ -18,34 +18,18 @@
 //! Error handling related code and Error/Result definitions.
 
 use futures::channel::oneshot;
-use thiserror::Error;
 
 use polkadot_node_subsystem::errors::RuntimeApiError;
 use polkadot_primitives::v1::SessionIndex;
 
-pub type Result<T> = std::result::Result<T, Error>;
-
-/// Errors for `Runtime` cache.
-#[derive(Debug, Error, derive_more::From)]
-#[error(transparent)]
+#[allow(missing_docs)]
+#[fatality::fatality(splitable)]
 pub enum Error {
-	/// All fatal errors.
-	Fatal(Fatal),
-	/// All nonfatal/potentially recoverable errors.
-	NonFatal(NonFatal),
-}
-
-/// Fatal runtime errors.
-#[derive(Debug, Error)]
-pub enum Fatal {
 	/// Runtime API subsystem is down, which means we're shutting down.
+	#[fatal]
 	#[error("Runtime request got canceled")]
 	RuntimeRequestCanceled(oneshot::Canceled),
-}
 
-/// Errors for fetching of runtime information.
-#[derive(Debug, Error)]
-pub enum NonFatal {
 	/// Some request to the runtime failed.
 	/// For example if we prune a block we're requesting info about.
 	#[error("Runtime API error {0}")]
@@ -56,13 +40,15 @@ pub enum NonFatal {
 	NoSuchSession(SessionIndex),
 }
 
+pub type Result<T> = std::result::Result<T, Error>;
+
 /// Receive a response from a runtime request and convert errors.
 pub(crate) async fn recv_runtime<V>(
 	r: oneshot::Receiver<std::result::Result<V, RuntimeApiError>>,
 ) -> Result<V> {
 	let result = r
 		.await
-		.map_err(Fatal::RuntimeRequestCanceled)?
-		.map_err(NonFatal::RuntimeRequest)?;
+		.map_err(FatalError::RuntimeRequestCanceled)?
+		.map_err(JfyiError::RuntimeRequest)?;
 	Ok(result)
 }