whatever_context with ?-based return requires type annotations when a transparent member exists in the error enum

[TapGhoul]

This is on Snafu 0.8.9, default features, on rust 1.90.0.

When creating a snafu error enum that uses a whatever-based return, the code fails to compile. Below is an example where this fails:

use snafu::{whatever, ResultExt, Snafu};

#[derive(Debug, Snafu)]
enum MyError {
    #[snafu(transparent)]
    SomeTransparentError { source: std::io::Error },

    #[snafu(whatever, display("{message}"))]
    SomeWhateverError {
        message: String,
        #[snafu(source(from(Box<dyn std::error::Error>, Some)))]
        source: Option<Box<dyn std::error::Error>>,
    },
}

fn broken_fn() -> Result<(), MyError> {
    inner_fn().whatever_context("some context")?;
    Ok(())
}

fn working_fn() -> Result<(), MyError> {
    inner_fn().whatever_context("some context")
}

fn inner_fn() -> Result<(), MyError> {
    whatever!("die");
}

The broken_fn() fails to compile with the following error:

error[E0284]: type annotations needed
  --> scheduler/src/buggy.rs:17:16
   |
17 |     inner_fn().whatever_context("some context")?;
   |                ^^^^^^^^^^^^^^^^ cannot infer type of the type parameter `E2` declared on the method `whatever_context`
   |
   = note: cannot satisfy `<_ as FromString>::Source == _`
help: consider specifying the generic arguments
   |
17 |     inner_fn().whatever_context::<&str, E2>("some context")?;
   |                                ++++++++++++

If you remove the #[snafu(transparent)] annotation, this compiles perfectly. You can have as many variants as you want, and it doesn't seem to matter what the transparent error actually is.

[shepmaster]

Thank you for providing such a nice description and reproducible test case!

Unfortunately, I'm not sure there's much to be done here. Here's my understanding...

1. Having a transparent error implements From for the error

   impl ::core::convert::From<std::io::Error> for MyError

2. whatever_context has the generic E2 which is determined from the return type

   fn whatever_context<S, E2>(self, context: S) -> Result<T, E2>

3. ? effectively calls Into::into on the error value.

Put all together, the code is along these pseudocode lines

let e: InitialError; // From `inner_fn`
let e = UnknownError::with_source(e.into(), ...); // From `whatever_context`
let e = ReturnError::from(e); // From `?`
return Err(e)

The problem is that the compiler cannot determine what the type UnknownError is.

When there's no transparent error, then there's only one applicable implementation of From, the identity transform, and the compiler can assume that's the right path to take.

Once a transparent error exists, the compiler doesn't know if the From for the ? operator should use the identity (which is what you want), or if it should use the From<std::io::Error> implementation.

That uncertainty then flows backward to the with_source method, which is reported as FromString.

In general, this is a problem as soon as there are multiple paths to get from type A to type B, or if there are multiple steps to get from A to B.

[shepmaster]

One note is that the compiler's suggestion is valid but overly specific. You can write:

inner_fn().whatever_context::<_, MyError>("some context")?;

[shepmaster]

Another option is that you can eschew SNAFU's ResultExt and create your own. This would allow you to hardcode E2 as your error type:

use snafu::FromString;

trait MyResultExt<T, E> {
    fn whatever_context<S>(self, context: S) -> Result<T, MyError>
    where
        S: Into<String>,
        E: Into<<MyError as FromString>::Source>;
}

impl<T, E> MyResultExt<T, E> for Result<T, E> {
    #[track_caller]
    fn whatever_context<S>(self, context: S) -> Result<T, MyError>
    where
        S: Into<String>,
        E: Into<<MyError as FromString>::Source>,
    {
        match self {
            Ok(v) => Ok(v),
            Err(error) => Err(MyError::with_source(error.into(), context.into())),
        }
    }
}

[shepmaster]

In the bigger picture, I'd encourage moving away from stringly-typed errors. SNAFU includes them to get people to report any error instead of panicking, but it's my hope that they get replaced with proper errors eventually.

[TapGhoul]

The problem is a lot of the time the context is just a note for me and isn't actually useful to provide a dedicated error value - so a whatever here would be replaced with nothing more than a StringContextSnafu(String) instead, or something to that effect. I prefer to annotate more parts of the call stack for context, but not all of these context points make sense to annotate in the sense of a dedicated error type. Think like tracing's #[instrument] attribute in that sense - it's application code, so it doesn't make as much sense to provide so many error variants, otherwise like a third of my code would be error variants lmao (that or I have to decide where to eliminate context - I prefer almost overdoing context in case I need it rather than erasing potentially important context I dismiss at the time)

The sort of pattern I am looking to do is a bunch of stacked errors, and while I do have a stack trace for this, having human readable info at each level of the trace makes it much easier to diagnose quickly - I use it far more like a human-readable stack trace than I do an actual error cascade.

[yshui]

Another option is that you can eschew SNAFU's ResultExt and create your own.

I was wondering if it would be better to generate a ResultExt with a concrete E2 type in #[derive], instead of providing a generic one from the crate.

Currently we can't mix #[snafu(whatever)] with either #[snafu(transparent)] or #[snafu(context(false))], or anything that would add a From impl to the Error type.

[yshui]

I made a proof of concept for this idea:

use snafu::prelude::*;
use snafu_ext::impl_context;

#[derive(Snafu, Debug)]
pub enum Error {
    #[snafu(display("Io"), context(false))]
    Io { source: std::io::Error },
    #[snafu(display("parse int"))]
    ParseInt { source: std::num::ParseIntError },
    #[snafu(whatever, display("{message}\n{backtrace}"))]
    Whatever {
        #[snafu(source(from(Box<dyn std::error::Error>, Some)))]
        source: Option<Box<dyn std::error::Error>>,
        message: String,
        backtrace: std::backtrace::Backtrace,
    },
}

impl_context!(snafu; Error);

fn main() -> Result<(), Error> {
    let _: u64 = "123456".parse().context(ParseIntSnafu)?;
    let _ = std::fs::File::open("/dev/null")?;

    #[allow(invalid_from_utf8)]
    let _ = str::from_utf8(&[0xff, 0xff]).whatever_context_ext("not utf8")?;
    Ok(())
}

https://docs.rs/snafu-ext/latest/snafu_ext/macro.impl_context.html