Move backtrace from one error to another inside From implementation

[dmitry-zakablukov]

Good day!

Snafu has a feature to delegate backtrace generation to source error:

#[derive(Debug, Snafu)]
enum Error {
    MyError {
        #[snafu(backtrace)]
        source: another::Error,
    },
}

But is there any way to delegate backtrace generation in other direction, from Error to another::Error in case when another::Error does know absolutely nothing about Error?
I have not found any way to do this, Box<dyn ErrorCompat> doesn't compile.

This feature will be helpfull for me, because I want to have a generic code in a generic library with it's own errors and traits. And have a case-specific library that implements traits from the generic one.

Below is a code with an example of my idea.

mod_a::Error knows nothing about mod_b::Error, but it have a generic error kind Internal for my case. And the only way to code to compile is to implement From<mod_b::Error> for mod_a::Error.

The problem is that inside the from() method I call build() on error. And this is where backtrace will point to, not the original error place in my code.

I want to know, is it possible to move backtrace from one error to another?

mod mod_a {
    use snafu::{Backtrace, Snafu};

    #[derive(Debug, Snafu)]
    #[snafu(visibility(pub))]
    pub enum Error {
        #[snafu(display("Internal: {}", details))]
        Internal {
            details: String,
            backtrace: Backtrace,
        },
    }
}

trait A {
    fn f(&self) -> Result<(), mod_a::Error>;
}

mod mod_b {
    use super::mod_a;
    use snafu::{Backtrace, Snafu};

    #[derive(Debug, Snafu)]
    #[snafu(visibility(pub))]
    pub enum Error {
        #[snafu(display("Some: {}", details))]
        SomeErr {
            details: String,
            backtrace: Backtrace,
        },
    }

    impl From<Error> for mod_a::Error {
        fn from(value: Error) -> Self {
            mod_a::InternalSnafu {
                details: value.to_string(),
            }
            .build() // <-- this is a line backtrace points to 
        }
    }
}

struct B;

impl B {
    pub fn do_smth(&self) -> Result<(), mod_b::Error> {
        Err(mod_b::SomeErrSnafu { 
            details: "error in B::do_smth()",
        }
        .build()) // <-- but I want a backtrace to point to this line
    }
}

impl A for B {
    fn f(&self) -> Result<(), mod_a::Error> {
        self.do_smth()?;
        Ok(())
    }
}

fn main() {
    let b = B {};
    println!("{:?}", b.f());
}

[shepmaster]

when another::Error does know absolutely nothing about Error

If I understand you, then the answer is "no".

If you know nothing about Error, then you wouldn't even know that it implements std::error::Error, so I assume that you don't mean this literally.

Even when you know that Error implements std::error::Error, that doesn't expose a stable API to get the backtrace. That's waiting on things like the provider API. snafu::ErrorCompat exists primarily to provide a way to get the backtrace while std::error::Error doesn't.

Even if the provider API were stable, it would return an Option<Backtrace> instead of Backtrace. It's debatable if you want to get it by value in the first place, as it would probably involve some expensive duplication or more knowledge about the inner error's implementation.

---

Box<dyn ErrorCompat> doesn't compile.

This may just be an oversight on our part. Perhaps adding appropriate where Self: Sized bounds on the trait would help. When I try it locally, I actually only get a warning — is that what you are seeing?

warning: the trait `ErrorCompat` cannot be made into an object
    --> /Users/shep/.cargo/registry/src/index.crates.io-6f17d22bba15001f/snafu-0.7.5/src/lib.rs:1000:8
     |
1000 |     fn iter_chain(&self) -> ChainCompat
     |        ^^^^^^^^^^
     |
     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
     = note: for more information, see issue #51443 <https://github.com/rust-lang/rust/issues/51443>
note: for a trait to be "object safe" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
    --> /Users/shep/.cargo/registry/src/index.crates.io-6f17d22bba15001f/snafu-0.7.5/src/lib.rs:1000:8
     |
1000 |     fn iter_chain(&self) -> ChainCompat
     |        ^^^^^^^^^^ the trait cannot be made into an object because method `iter_chain` references the `Self` type in its `where` clause
     = note: `#[warn(where_clauses_object_safety)]` on by default

---

Incidentally, Err(XxxSnafu { ... }.build()) can be written as XxxSnafu { ... }.fail()

[dmitry-zakablukov]

If you know nothing about Error ...

Well, let me rephrase my thought.

mod_a::Error doesn't know anything about external modules. But! An author of mod_b knows that mod_a::Error is a Snafu error and that mod_b::Error is also is a Snafu error. So, we have mod_a::InternalSnafu with a backtrace and mod_b::SomeErrSnafu with a backtrace.

I can move mod_a::InternalSnafu::backtrace into mod_b::SomeErrSnafu::backtrace using this:

#[snafu(backtrace)]
source: mod_a::Error,

But I can't move mod_b::SomeErrSnafu::backtrace into mod_a::InternalSnafu::backtrace inside of From<mod_b::Error> for mod_a::Error implementation if mod_a doesn't know about an existence of mod_b::Error!

---

So, the idea is to somehow extract a backtrace from mod_b::Error and inject the backtrace into mod_a::InternalSnafu. Something like this:

mod_a::InternalSnafu {
    details: value.to_string(),
    backtrace: ErrorCompat::backtrace(&value)
}

or like this:

mod_a::InternalSnafu {
    details: value.to_string(),
}.adopt_backtrace(&value)

[dmitry-zakablukov]

is that what you are seeing?

Yes, I see the same warning. But the problem is that I cannot make my code to compile with a Box<dyn Smth> as a source of a Snafu error.
So, the warning is the least my problem in this approach with Box.

[shepmaster]

somehow extract a backtrace

Right, and that's not possible with std::error::Error (with or without the provider API) or snafu::ErrorCompat. All of those routes will give you a Option<&Backtrace> — a reference to the backtrace inside the error.

This works well for the delegation case as the outer error owns the inner error and can ask for the reference.

In your case, you wish to take ownership of the inner error (From<Error>), get the string value (.to_string()) then throw away the error containing the backtrace. Any reference to the backtrace would become invalid and the compiler would stop you.

If you need to be generic, you need is a completely separate trait. If you don't need to be generic, you will need to enhance your types. For example, here I match on one Error, grab the backtrace out, then construct the other error manually.

mod mod_a {
    use snafu::{Backtrace, Snafu};

    #[derive(Debug, Snafu)]
    #[snafu(visibility(pub))]
    pub enum Error {
        #[snafu(display("Internal: {}", details))]
        Internal {
            details: String,
            backtrace: Backtrace,
        },
    }
}

trait A {
    fn f(&self) -> Result<(), mod_a::Error>;
}

mod mod_b {
    use super::mod_a;
    use snafu::{Backtrace, Snafu};

    #[derive(Debug, Snafu)]
    #[snafu(visibility(pub))]
    pub enum Error {
        #[snafu(display("Some: {}", details))]
        SomeErr {
            details: String,
            backtrace: Backtrace,
        },
    }

    impl From<Error> for mod_a::Error {
        fn from(value: Error) -> Self {
            let details = value.to_string();
            let Error::SomeErr { backtrace, .. } = value;

            mod_a::Error::Internal { details, backtrace }
        }
    }
}

struct B;

impl B {
    pub fn do_smth(&self) -> Result<(), mod_b::Error> {
        Err(mod_b::SomeErrSnafu {
            details: "error in B::do_smth()",
        }
        .build()) // <-- but I want a backtrace to point to this line
    }
}

impl A for B {
    fn f(&self) -> Result<(), mod_a::Error> {
        self.do_smth()?;
        Ok(())
    }
}

fn main() {
    let b = B {};
    println!(
        "{}",
        snafu::ErrorCompat::backtrace(&b.f().unwrap_err()).unwrap()
    );
}

You'd probably create a function instead of creating the enum like that, but the idea is the same.

[dmitry-zakablukov]

@shepmaster , I have found a solution for my case!

    impl From<Error> for mod_a::Error {
        fn from(value: Error) -> Self {
            mod_a::Error::Internal {
                details: value.to_string(),
                backtrace: value.backtrace().unwrap().clone(),
            }
        }
    }

Yes, it doesn't move backtrace, but at least this code produces an error with the same backtrace inside mod_a::Error::Internal and this was my initial goal.

[dmitry-zakablukov]

Yes, the only generic way to implement the moving of the backtrace is to implement it inside snafu crate.

I do not fully understand how error.backtrace() is implemented, but I believe it is possible to implement fn extract_backtrace(self) -> Option<snafu::Backtrace> in the same manner as backtrace() does it, but instead of returning a reference to backtrace field it should return a backtrace value itself.

@shepmaster , what do you think is it possible to implement such a method extract_backtrace() inside of snafu crate?

[shepmaster]

Yes, the only generic way to implement the moving of the backtrace is to implement it inside snafu crate.

That is not accurate. As I said earlier:

If you need to be generic, you need is [sic] a completely separate trait.

That trait doesn't need to be owned by SNAFU. For example, you can add this to my earlier example:

trait ExtractBacktrace {
    fn extract_backtrace(self) -> snafu::Backtrace;
}

impl ExtractBacktrace for mod_b::Error {
    fn extract_backtrace(self) -> snafu::Backtrace {
        let mod_b::Error::SomeErr { backtrace, .. } = self;
        backtrace
    }
}

// ...

    impl From<Error> for mod_a::Error {
        fn from(value: Error) -> Self {
            let details = value.to_string();
            let backtrace = value.extract_backtrace();

            mod_a::Error::Internal { details, backtrace }
        }
    }

You could even make your From more generic:

    impl<E> From<E> for mod_a::Error
    where
        E: snafu::Error + ExtractBacktrace
    {
        fn from(value: E) -> Self {
            let details = value.to_string();
            let backtrace = value.extract_backtrace();

            mod_a::Error::Internal { details, backtrace }
        }
    }

However, being generic won't work with From if you implement ExtractBacktrace for mod_a::Error. In that case you'd need to use a custom function:

    impl mod_a::Error {
        pub(crate) fn from_error_with_backtrace<E>(value: E) -> Self
        where
            E: snafu::Error + ExtractBacktrace
        {
            let details = value.to_string();
            let backtrace = value.extract_backtrace();

            mod_a::Error::Internal { details, backtrace }
        }
    }

// ...

        self.do_smth().map_err(mod_a::Error::from_error_with_backtrace)?;

[shepmaster]

do you think is it possible to implement such a method extract_backtrace() inside of snafu crate?

As shown in my previous reply, it's possible to implement it outside of SNAFU, so it's certainly possible to do it inside. The question then becomes whether or not we should. My default position is that no, we should not.

I don't want SNAFU to extend what the standard library does for errors via std::error::Error; ideally it just makes implementing and using std::error::Error easier. From a consumer's point-of-view, they shouldn't be able to tell that SNAFU was used to create a given error ¹.

The standard library had the unstable Error::backtrace method and that's what we mirrored ErrorCompat::backtrace on. That has since been removed in favor of the provider API. The provider API will allow getting the signatures fn(&self) -> Option<&Backtrace> and fn(&self) -> Option<Backtrace>, but not fn(self) -> Option<Backtrace>.

For those reasons, I don't see adding something to SNAFU without a broader community demand.

Footnotes

1. this isn't currently true, as the implementation snafu::ErrorCompat can easily leak. That's one reason I am excited to see the provider API stabilize. ↩

[dmitry-zakablukov]

My default position is that no, we should not.

That is all I want to know. )

@shepmaster , thank you for your help, I understand now what my options are and will be going to implement one of them.

[shepmaster]

I do think that this raises the question of "how could you embed an arbitrary error and get a backtrace out".

One way today is to make your error type generic:

use snafu::{prelude::*, ErrorCompat};

mod mod_a {
    use snafu::prelude::*;

    #[derive(Debug, Snafu)]
    #[snafu(visibility(pub))]
    pub enum Error<I>
    where
        I: snafu::Error + snafu::ErrorCompat + 'static,
    {
        #[snafu(display("Internal: {source}"))]
        Internal {
            #[snafu(backtrace)]
            source: I,
        },
    }
}

trait A {
    fn f(&self) -> Result<(), mod_a::Error<mod_b::Error>>;
}

mod mod_b {
    use snafu::{prelude::*, Backtrace};

    #[derive(Debug, Snafu)]
    #[snafu(visibility(pub))]
    pub enum Error {
        #[snafu(display("Some: {}", details))]
        SomeErr {
            details: String,
            backtrace: Backtrace,
        },
    }
}

struct B;

impl B {
    pub fn do_smth(&self) -> Result<(), mod_b::Error> {
        Err(mod_b::SomeErrSnafu {
            details: "error in B::do_smth()",
        }
        .build()) // <-- I want a backtrace to point to this line
    }
}

impl A for B {
    fn f(&self) -> Result<(), mod_a::Error<mod_b::Error>> {
        self.do_smth().context(mod_a::InternalSnafu)?;
        Ok(())
    }
}

fn main() {
    let b = B {};
    println!("{}", ErrorCompat::backtrace(&b.f().unwrap_err()).unwrap());
}

I have to think more how to do a trait object based version.