[Feature request] Enabling support for transitive "#[from]' handling

[HatemMn]

I will explain myself with a very simple example :

Say I have this huge error type on my codebase :

#[derive(Error, Debug)]
pub enum MyError {
    #[error("Network error: {0}")]
    Network(String),

    #[error("Conversion Error: {0}")]
    ConversionError(#[from] ConversionDbError),

    // Around 30 other variants

And with

#[derive(Error, Debug)]
pub enum ConversionDbError {
    #[error("UUID conversion error: {0}")]
    Uuid(#[from] uuid::Error),

    #[error("UTF-8 conversion error: {0}")]
    FromUtf8(#[from] std::string::FromUtf8Error),

    #[error("TryFromIntError conversion error: {0}")]
    TryFromInt(#[from] std::num::TryFromIntError),
}

I still need to add the manual conversions in order to forward the error down my enum :

impl From<uuid::Error> for DbError {
    fn from(e: uuid::Error) -> Self {
        Self::ConversionError(ConversionDbError::Uuid(e))
    }
}
// and the 2 others

This kindof takes away my goal from importing the thiserror crate, which is to reduce boilerplate redundant code to the maximum. Of course, the code above isn't my production code. My code is so huge that this kind of feature will make it way more human-friendly.

Am I doing smth wrong or this is a feature that can be implemented ?

[TuTiuTe]

I also encountered this issue, but tried to look at it from a feasibility / proc_macro standpoint.

In your example, your error is called MyError but later called DbError, I'll go with DbError.

proc_macros only have the context of the object right below them, so when the first derive(Error) looks at DbError, and then at its field ConversionDbError, it has no clue what it is an enum, with a field Uuid, that can be converted to ConversionDbError.

This could be solved by a macro giving more context to derive(Error), so for instance:

#[derive(Error, Debug)]
pub enum MyError {
    #[error("Network error: {0}")]
    Network(String),

    #[error("Conversion Error: {0}")]
    #[from(uuid::Error)]
    ConversionError(#[from] ConversionDbError),

    // Around 30 other variants

In which case the macro could expand to

impl From<uuid::Error> for DbError {
    fn from(e: uuid::Error) -> Self {
        Self::ConversionError(e.into())
    }
}

Note that this is only theoretical and I did not try it out nor am I affiliated with this project