add missing impl Errors

use `thiserror` to do this as it's already used in the crate. this
updates it from v1 to v2 and also uses it in `no_std` environments as
that's now supported by `thiserror`.

this was missing and thus it wasn't possible to use e.g. `HostErr` in a
`#[from]` with `thiserror`.

Author: rursprung

example/workbook-host/Cargo.lock

@@ -64,8 +64,8 @@ version = "0.3.69"
 optional = true
 
 [dependencies.thiserror]
-version = "1.0"
-optional = true
+version = "2"
+default-features = false
 
 [dependencies.web-sys]
 
@@ -195,7 +195,7 @@ use-std = [
     "dep:tokio",
     "postcard/use-std",
     "postcard-schema/use-std",
-    "dep:thiserror",
+    "thiserror/std",
     "dep:tracing",
     "dep:trait-variant",
     "dep:ssmarshal",

source/postcard-rpc-test/Cargo.lock

@@ -13,7 +13,6 @@ use std::{
         Arc, RwLock,
     },
 };
-
 use thiserror::Error;
 
 use maitake_sync::{
@@ -52,28 +51,26 @@ pub(crate) mod util;
 pub mod test_channels;
 
 /// Host Error Kind
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Error)]
 pub enum HostErr<WireErr> {
     /// An error of the user-specified wire error type
+    #[error("a wire error occurred")]
     Wire(WireErr),
     /// We got a response that didn't match the expected value or the
     /// user specified wire error type
     ///
     /// This is also (misused) to report when duplicate sequence numbers
     /// in-flight at the same time are detected.
+    #[error("the response received didn't match the expected value or the wire error type")]
     BadResponse,
     /// Deserialization of the message failed
-    Postcard(postcard::Error),
+    #[error("message deserialization failed")]
+    Postcard(#[from] postcard::Error),
     /// The interface has been closed, and no further messages are possible
+    #[error("the interface has been closed, and no further messages are possible")]
     Closed,
 }
 
-impl<T> From<postcard::Error> for HostErr<T> {
-    fn from(value: postcard::Error) -> Self {
-        Self::Postcard(value)
-    }
-}
-
 impl<T> From<WaitError> for HostErr<T> {
     fn from(_: WaitError) -> Self {
         Self::Closed
@@ -230,17 +227,23 @@ where
 }
 
 /// Errors related to retrieving the schema
-#[derive(Debug)]
+#[derive(Debug, Error)]
 pub enum SchemaError<WireErr> {
     /// Some kind of communication error occurred
-    Comms(HostErr<WireErr>),
+    #[error("A communication error occurred")]
+    Comms(#[from] HostErr<WireErr>),
     /// An error occurred internally. Please open an issue.
+    #[error("An error occurred internally. Please open an issue.")]
     TaskError,
     /// Invalid report data was received, including endpoints or
     /// tasks that referred to unknown types. Please open an issue
+    #[error("Invalid report data was received. Please open an issue.")]
     InvalidReportData,
     /// Data was lost while transmitting. If a retry does not solve
     /// this, please open an issue.
+    #[error(
+        "Data was lost while transmitting. If a retry does not solve this, please open an issue."
+    )]
     LostData,
 }
 

source/postcard-rpc/Cargo.toml

@@ -18,6 +18,7 @@ use crate::{
     Topic,
 };
 use core::fmt::Arguments;
+use thiserror::Error;
 use tokio::{select, sync::mpsc};
 
 //////////////////////////////////////////////////////////////////////////////
@@ -212,9 +213,10 @@ impl WireTx for ChannelWireTx {
 }
 
 /// A wire tx error
-#[derive(Debug)]
+#[derive(Debug, Error)]
 pub enum ChannelWireTxError {
     /// The receiver closed the channel
+    #[error("channel closed")]
     ChannelClosed,
 }
 
@@ -279,11 +281,13 @@ impl WireRx for ChannelWireRx {
 }
 
 /// A wire rx error
-#[derive(Debug)]
+#[derive(Debug, Error)]
 pub enum ChannelWireRxError {
     /// The sender closed the channel
+    #[error("channel closed")]
     ChannelClosed,
     /// The sender sent a too-large message
+    #[error("message too large")]
     MessageTooLarge,
 }
 

source/postcard-rpc/src/host_client/mod.rs

@@ -29,13 +29,13 @@ pub mod impls;
 
 use core::{fmt::Arguments, ops::DerefMut};
 
-use postcard_schema::Schema;
-use serde::Serialize;
-
 use crate::{
     header::{VarHeader, VarKey, VarKeyKind, VarSeq},
     DeviceMap, Key, TopicDirection,
 };
+use postcard_schema::Schema;
+use serde::Serialize;
+use thiserror::Error;
 
 //////////////////////////////////////////////////////////////////////////////
 // TX
@@ -77,21 +77,24 @@ pub trait WireTx {
 }
 
 /// The base [`WireTx`] Error Kind
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, Error)]
 #[non_exhaustive]
 pub enum WireTxErrorKind {
     /// The connection has been closed, and is unlikely to succeed until
     /// the connection is re-established. This will cause the Server run
     /// loop to terminate.
+    #[error("connection closed")]
     ConnectionClosed,
     /// Other unspecified errors
+    #[error("other")]
     Other,
     /// Timeout (WireTx impl specific) reached
+    #[error("timeout reached")]
     Timeout,
 }
 
 /// A conversion trait to convert a user error into a base Kind type
-pub trait AsWireTxErrorKind {
+pub trait AsWireTxErrorKind: core::error::Error {
     /// Convert the error type into a base type
     fn as_kind(&self) -> WireTxErrorKind;
 }
@@ -127,21 +130,24 @@ pub trait WireRx {
 }
 
 /// The base [`WireRx`] Error Kind
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, Error)]
 #[non_exhaustive]
 pub enum WireRxErrorKind {
     /// The connection has been closed, and is unlikely to succeed until
     /// the connection is re-established. This will cause the Server run
     /// loop to terminate.
+    #[error("connection closed")]
     ConnectionClosed,
     /// The received message was too large for the server to handle
+    #[error("the received message was too large for the server to handle")]
     ReceivedMessageTooLarge,
     /// Other message kinds
+    #[error("other")]
     Other,
 }
 
 /// A conversion trait to convert a user error into a base Kind type
-pub trait AsWireRxErrorKind {
+pub trait AsWireRxErrorKind: core::error::Error {
     /// Convert the error type into a base type
     fn as_kind(&self) -> WireRxErrorKind;
 }
@@ -384,15 +390,18 @@ where
 }
 
 /// A type representing the different errors [`Server::run()`] may return
+#[derive(Debug, Error)]
 pub enum ServerError<Tx, Rx>
 where
     Tx: WireTx,
     Rx: WireRx,
 {
     /// A fatal error occurred with the [`WireTx::send()`] implementation
-    TxFatal(Tx::Error),
+    #[error("A fatal error occurred while transmitting")]
+    TxFatal(#[source] Tx::Error),
     /// A fatal error occurred with the [`WireRx::receive()`] implementation
-    RxFatal(Rx::Error),
+    #[error("A fatal error occurred while receiving")]
+    RxFatal(#[source] Rx::Error),
 }
 
 impl<Tx, Rx, Buf, D> Server<Tx, Rx, Buf, D>