How to map one source Error type to different SNAFU Error variants?

[dominickpastore]

This seems like it should be a not-too-uncommon situation, so I apologize if it's a simple question, but I can't figure out the best way to handle it.

I have a particular library error type that I need to map to different variants of my application's error type, depending on the contents of the error, and I want that to happen every time that error is encountered.

To give some more context: Before I started using SNAFU, I used this From impl to do the job:

impl From<ZBusError> for Error {
    fn from(value: ZBusError) -> Self {
        match value {
            ZBusError::MethodError(err, msg, full_msg) =>
                match err.as_str() {
                    "net.connman.iwd.Busy" => Error::WifiBusy(msg),
                    "net.connman.iwd.Failed" => Error::IwdFailure(msg),
                    _ => Error::DBus(ZBusError::MethodError(err, msg, full_msg)),
                }
            _ => Error::DBus(value)
        }
    }
}

Basically, ZBusError represents any number of issues that can occur when doing a remote method call over D-Bus, including an error response from the remote end. The particular service I'm interacting with has these two generic errors that it could return for any method call, and I always want to handle those two specially with their own variants (Error::WifiBusy and Error::IwdFailure). All other cases of ZBusError can become Error::DBus.

With SNAFU, the two ways I've thought of to handle this are:

• Keep using a From impl like above, but implemented for the SNAFU error (e.g. with WifiBusySnafu { msg }.into_error(value), etc.)
• Use a pattern match every time I have a Result<_, ZBusError> to figure out which context selector to use

The first almost seems like it would work, except if there's an implicitly-generated backtrace or Location in the SNAFU error (which I'd really like to have—it's the main reason I'm adopting SNAFU), I'd expect it to take them from inside the From impl instead of at the site where the error result actually happened.

The second way wouldn't suffer from that problem, but it'd lead to a lot of repetitive code. There are many places I need to handle this type of error.

Is there a better way to do this?

[8573]

The first almost seems like it would work, except if there's an implicitly-generated backtrace or Location in the SNAFU error (which I'd really like to have—it's the main reason I'm adopting SNAFU), I'd expect it to take them from inside the From impl instead of at the site where the error result actually happened.

Would applying #[track_caller] to the fn from help?

[dominickpastore]

It might. I'll have to try it. (And in case it wasn't clear from the original post, I don't actually know for sure whether from would get it wrong without that in the first place. I assumed it would, but I didn't actually try it.)

[dominickpastore]

I just tried it and:

1. The Location was in fact taken from inside the from function when implemented that way
2. Applying #[track_caller] did fix that concern.

My actual code wasn't in a state where I could easily test it, so I used a toy example:

use snafu::{Backtrace, IntoError, Location};
use snafu::prelude::*;
use crate::unpack::{unpack_singleton, UnpackError};

mod unpack {
    use std::error::Error;
    use std::fmt::{Display, Formatter};

    #[derive(Debug)]
    pub enum UnpackError {
        BadSize(usize),
    }

    impl Display for UnpackError {
        fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
            match self {
                UnpackError::BadSize(len) =>
                    write!(f, "Vector length {} is not 1", len),
            }
        }
    }

    impl Error for UnpackError {}

    pub fn unpack_singleton<T>(mut vec: Vec<T>) -> Result<T, UnpackError> {
        if vec.len() != 1 {
            Err(UnpackError::BadSize(vec.len()))
        } else {
            Ok(vec.remove(0))
        }
    }
}

#[derive(Debug, Snafu)]
enum MainError {
    #[snafu(display("Vec was empty"))]
    EmptyVec {
        source: UnpackError,
        backtrace: Backtrace,
        location: Location,
    },
    #[snafu(display("Vec had too many items: {len}"))]
    OverfullVec {
        len: usize,
        source: UnpackError,
        backtrace: Backtrace,
        location: Location,
    }
}

impl From<UnpackError> for MainError {
    #[track_caller]
    fn from(value: UnpackError) -> Self {
        match value {
            UnpackError::BadSize(0) => {
                EmptyVecSnafu.into_error(value)
            }
            UnpackError::BadSize(len) => {
                OverfullVecSnafu { len }.into_error(value)
            }
        }
    }
}

fn main() -> Result<(), MainError> {
    println!("Unpacking [8]");
    let num = unpack_singleton(vec![8])?;
    println!("Got: {}", num);

    println!("Unpacking [2, 3, 4]");
    let num = unpack_singleton(vec![2, 3, 4])?;
    println!("Got: {}", num);

    Ok(())
}