Creating anyhow! from Arc<Error> miss error source

[mickaelmagniez]

I'm trying to convert a Arc<Error> (returned by moka crate) to an Error

So what i basically do is

moka().map_err(|e| anyhow::anyhow!(e))?

But doing this, i lose information, before the map_err, printing with {:#} give me all the chained errors, but after the map_err, i get only the last one.

I've reproduced issue with the following code

let error1 = anyhow::Error::msg("error1");
let error2 = anyhow::Error::from(error1).context("error2");
println!("error 2 '{:#}'", error2);
println!("error 2 src '{:?}'", error2.source());

is printing

error 2 'error2: error1'
error 2 src 'Some("error1")'

Recreating an error from error2 still works

let error_from_error = anyhow::anyhow!(error2);

But if i try to do this this an Arc

let arc_error = std::sync::Arc::new(error2);
let error_from_arc = anyhow::anyhow!(arc_error);
println!("src '{:?}'",  error_from_arc.source());
println!("error_from_arc '{:#}'", error_from_arc);

is printing

src 'None'
error_from_arc 'error2'

But

println!("error_from_arc '{:#?}'", error_from_arc);

is printing

error_from_arc 'Error {
    context: "error2",
    source: "error1",
}'

[ouillie]

This would be useful where errors need to be cloned, for instance when dealing with shared futures (I'm assuming Moka has a similar reason for doing this).

Here's an illustration of why I need a cloneable error type for my use-case:

use anyhow::Error;
use futures::future::Shared;
use futures::FutureExt;

/// This function returns a shared future to support polling by multiple tasks.
/// That requires the result to be `Clone`.
/// The hypothetical `Foo` type is `Clone`, and I want to use `Arc<anyhow::Error>` as a cloneable error type.
fn returns_shared_future()
    -> Shared<Pin<Box<dyn Future<Output = StdResult<Foo, Arc<Error>>> + Send>>>
{
    spawn(do_the_work())
        .map(|result| {
            result
                .context("Failure joining background task")
                .map_err(Arc::new)?
                .context("Failure doing the work")
                .map_err(Arc::new)
        })
        .boxed()
        .shared()
}

async fn do_the_work() -> StdResult<Foo, Error> {
    // Important context added to errors in here.
}

So, I could just use a different cloneable error type, but then I'd be duplicating a lot of the logic in anyhow, and I feel like anyhow might be able to support this with a relatively simple API -- something like this:

use anyhow::Error;

let shared_error: Arc<Error> = get_shared_error();

// Error::shared() would craft some sort of vtable to propagate sources when calling `.chain()` etc.
let error: Error = Error::shared(shared_error.clone());

Anybody have a read on the feasibility of this? I must admit I find the anyhow source hard to read (which is certainly more my fault than the authors').