Pure Source Error with Location

[cloud303-cholden]

Hello! I'm looking for an ergonomic solution to adding error Location details to source errors. My current approach works, but I'm curious if there's a more concise alternative.

Here is my current code:

#[derive(snafu::Snafu)]
enum Error {
    ...

    #[snafu(display(
        "{} ({}:{}:{})",
        source,
        location.file,
        location.line,
        location.column,
    ))]
    Env {
        source: std::env::VarError,
        location: snafu::Location,
    },

    ...
}

impl std::fmt::Debug for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self, f)
    }
}

fn main() -> Result<(), Error> {
    let variable = std::env::var("MISSING_VARIABLE").context(EnvSnafu)?;
}

And the error response:

Error: environment variable not found (src/main.rs:100:100)

And a possible desired version:

#[derive(snafu::Snafu)]
enum Error {
    ...

    #[snafu(something_custom)]
    Env,

    ...
}

impl std::fmt::Debug for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self, f)
    }
}

fn main() -> Result<(), Error> {
    let variable = std::env::var("MISSING_VARIABLE").context(EnvSnafu)?;
}

[shepmaster]

I can't immediately think of a great way to do this with SNAFU.

---

I'm not sure I completely understand what it is you want to do, but extrapolating from "adding error Location details to source errors", it sounds like you want to make it easier for the programmer. If that's the case, it seems like you'd want something syntactically like

std::env::var("MISSING_VARIABLE").add_location()?;
std::io::read('/foo').add_location()?;
foo.try_into().add_location()?;

However, I'd highly discourage such a path because the error message is basically useless to the person running the program:

Error: environment variable not found (src/main.rs:100:100)

One of the biggest points of SNAFU is that you add context to the error that makes it sensical to the caller (which eventually is the person running the program).

99.9% of the time, errors I create do not use Location or Backtrace because each error is only ever constructed in exactly one location anyway. From this, you get what I refer to as a "semantic stacktrace", one that doesn't map to the programmer's view of the world, but to how the program is functionally composed. There's no reason to even keep the traditional stacktrace because you can reconstruct it from which errors occurred.

---

All that being said, if you wanted to get some syntax close to what you propose, you could create your own macro (I think either procedural or declarative would work) that does the transform for you. Your example doesn't have std::env::VarError in it anymore, so I'm not sure if that's a typo or desired. If the latter, I believe that problem to be impossible to solve in today's Rust.

If you wanted to reduce the noise from ({}:{}:{})", location.file, location.line, location.column, you could create your own newtype around SNAFU's Location that delegates to snafu::GenerateImplicitData and then implements Display in your chosen manner.

[cloud303-cholden]

Thank you for the detailed response. I like the idea of the "semantic backtrace". I should probably mention that my use case for SNAFU is to simplify troubleshooting Rust microservices for work where I'm the sole maintainer. My primary goal is to make writing Rust code and tracking bugs as quick and simple as possible. So in my case, the source error and line number are usually all I need. My instinct is that I'm going about this wrong given that my desired result appears simple while my solution is pretty verbose. Any advice you could offer is welcome, but I think your suggestions answer my initial question.