Dealing with foreign errors

[JustSimplyKyle]

Since the introduction of typed-errors, I've encountered the following problem(and workarounds).

std::io::Error

since it's a foreign type, we have to mirror it.
but the underlying type is quite complex( pub(super) struct Repr(NonNull<()>, PhantomData<ErrorData<Box<Custom>>>);
but what we can try to do instead is to use the type ErrorKind in std::io, which we can acquire by calling .kind()
but now we encounter a separate issue

the check for if we implemented all variants of the ErrorKind enum fails, since it assumes we have to implement all the variants, including unstable ones

so the only way is to create a completely custom type

// we don't use the mirror feature because it will force us to use unstable rust
#[derive(Debug, Clone)]
pub enum CustomIoErrorKind {
    NotFound,
    PermissionDenied,
    AlreadyExists,
    InvalidInput,
    TimedOut,
    Other,
}

reqwest::Error

Now this is interesting, since there is no default way to get the underlying Kind(it's in a private field. So we gotta use if and else if instead of the nice match statments.

impl From<reqwest::Error> for DownloadError {
    fn from(value: reqwest::Error) -> Self {
        if value.is_builder() {
            todo!()
        } else if value.is_redirect() {
            todo!()
        } else if value.is_status() {
            todo!()
        } // ... and you get it
        else {
            unreachable!()
        }
    }
}

hex::FromHexError

#[derive(Debug, Clone, Copy, PartialEq)]
pub enum FromHexError {
    InvalidHexCharacter { c: char, index: usize },
    OddLength,
    InvalidStringLength,
}

ayy an enum we can actually mi-
well, sadly the mirror feature doesn't support enums with struct variants
so we have to once again create a custom error kind type, but at least we get to use match!(which is exhausitive)

impl From<FromHexError> for ShasumValidationError {
    fn from(value: FromHexError) -> Self {
        match value {
            FromHexError::InvalidHexCharacter { c, index } => {
                Self::FailToDecode(HexErrorKind::InvalidHexCharacter { c, index })
            }
            FromHexError::OddLength => Self::FailToDecode(HexErrorKind::OddLength),
            FromHexError::InvalidStringLength => {
                Self::FailToDecode(HexErrorKind::InvalidStringLength)
            }
        }
    }
}

Conclusion

These from implements we have to manually imp kind of takes away the ergonomics improvements that thiserror provides(at least for foreign type)

[fzyzcjy]

Hmm...

the check for if we implemented all variants of the ErrorKind enum fails, since it assumes we have to implement all the variants

Maybe we can create some configurations to allow us to ignore some kinds? Say, #[frb(please_ignore_these_variants=[HostUnavailable, NetworkUnreachable])]. (or any kind of other configurations)

Now this is interesting, since there is no default way to get the underlying Kind(it's in a private field. So we gotta use if and else if instead of the nice match statments.

I am not sure, maybe create an issue at reqwest - since a lot of crates just expose errors as public fields.

well, sadly the mirror feature doesn't support enums with struct variants

This looks like a implementable thing

These from implements we have to manually imp kind of takes away the ergonomics improvements that thiserror provides(at least for foreign type)

Btw this reminds me of a thing: When using those errors, it seems we are missing a stack trace - unlike when we are using anyhow or thiserror-with-stacktrace? I personally feel stacktrace quite helpful.