Confusing compiler error when returning a `Result<Result>` via `?`-operator

[sdroege]

Given the following code: https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=9aac41ba36103dac1f4ae20fa30c86f0

fn foo(x: Option<i32>) -> Result<(), &'static str> {
    let _ = x.ok_or_else(|| Err("nope"))?;
    Ok(())
}

fn main() {
    println!("{:?}", foo(Some(1)));
}

The current output is:

error[E0277]: `?` couldn't convert the error to `&str`
 --> src/main.rs:2:41
  |
1 | fn foo(x: Option<i32>) -> Result<(), &'static str> {
  |                           ------------------------ expected `&str` because of this
2 |     let _ = x.ok_or_else(|| Err("nope"))?;
  |                                         ^ the trait `From<Result<_, &str>>` is not implemented for `&str`
  |
  = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
  = note: required by `from`

Ideally the output would mention the double-Result wrapping ("got type Result<Result<...>> expected ...") and suggest removing one layer or Result::flatten() or similar.

It kind of does the former already if you squint but it's far from obvious ("the trait From<Result<_, &str>> is not implemented for &str").

[scottmcm]

The error on nightly is a bit different now, post rust-lang/rfcs#3058

error[E0277]: `?` couldn't convert the error to `&str`
 --> src/main.rs:2:41
  |
1 | fn foo(x: Option<i32>) -> Result<(), &'static str> {
  |                           ------------------------ expected `&str` because of this
2 |     let _ = x.ok_or_else(|| Err("nope"))?;
  |                                         ^ the trait `From<Result<_, &str>>` is not implemented for `&str`
  |
  = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
  = note: required because of the requirements on the impl of `FromResidual<Result<Infallible, Result<_, &str>>>` for `Result<(), &str>`
  = note: required by `from_residual`

That does have the double-nest mentioned (Result<Infallible, Result<_, &str>>), though still not super-obviously.

(It'll be a bit clearer once ! stabilizes and it can shorten to Result<!, Result<_, &str>>.)

[756445638]

fn foo(x: Option<i32>) -> Result<(), &'static str> {
    let _ = x.ok_or_else(|| Err(      &         "nope"))?;
    Ok(())
}

fn main() {
    println!("{:?}", foo(Some(1)));
}

is this better, I think this should works fine and compile ok.

[756445638]

the compiler is right!!

try will desuger to this

/// Desugar `ExprKind::Try` from: `<expr>?` into:
/// ```rust
/// match Try::into_result(<expr>) {
///     Ok(val) => #[allow(unreachable_code)] val,
///     Err(err) => #[allow(unreachable_code)]
///                 // If there is an enclosing `try {...}`:
///                 break 'catch_target Try::from_error(From::from(err)),
///                 // Otherwise:
///                 return Try::from_error(From::from(err)),
/// }
/// ```

x.ok_or_else(|| Err("nope"))?

will be

match Try::into_result(x.ok_or_else(|| Err("nope"))) {
    Ok(val) => val ,
    Err(err) => return Try::from_error(err)
    //err is &str ,
    //and the trait `From<Result<_, &str>>` is not implemented for `&str`
    //and you cannot impl From<Result<_, &str>> for &str {}.
}

[scottmcm]

@756445638 Oops, I forgot to update that comment. Fixed with PR #86994

[756445638]

@scottmcm ok I just notice that!