It'd be useful to delay E0412 after type checking to improve suggestions

[estebank]

With the following code:

async fn foo(i: usize, uri: Uri) -> Result<Duration, Error> {
    let client = Client::new();
    let now = Instant::now();
    match await!(client.get(uri).timeout(Duration::from_secs(20))) {
        Ok(_) => {
            Ok(Instant::now() - now)
        }
        Err(err) => Err(err),
    }
}

the diagnostic rightly complains about not knowing what Error is

error[E0412]: cannot find type `Error` in this scope
  --> src/main.rs:11:54
   |
11 | async fn foo(i: usize, uri: Uri) -> Result<Duration, Error> {
   |                                                      ^^^^^ not found in this scope
help: possible candidates are found in other modules, you can import them into scope
   |
5  | use core::fmt::Error;
   |
5  | use futures::core_reexport::fmt::Error;
   |
5  | use futures::io::Error;
   |
5  | use futures::rand_reexport::Error;
   |
and 10 other candidates

but it could use the information gathered later to limit the suggestions. If we change Error in the return type to (), the output is

error[E0271]: type mismatch resolving `<impl std::future::Future as std::future::Future>::Output == std::result::Result<std::time::Duration, ()>`
  --> src/main.rs:11:37
   |
11 | async fn foo(i: usize, uri: Uri) -> Result<Duration, ()> {
   |                                     ^^^^^^^^^^^^^^^^^^^^ expected struct `tokio_timer::timeout::Error`, found ()
   |
   = note: expected type `std::result::Result<_, tokio_timer::timeout::Error<hyper::error::Error>>`
              found type `std::result::Result<_, ()>`
   = note: the return type of a function must have a statically known size

[Enselic]

Triage: Can this still be reproduced? I would check myself if I could but that would need a minimal reproducer. What is Client? What is Uri? (I suspect it was obvious when the issue what written, but I don't find it obvious any longer.)

[estebank]

The specific types aren't important, a minimal reproducer would be

fn foo() -> Result<(), Name> {
    bar()
}

fn bar() -> Result<(), ()> {
    Ok(())
}
fn main() {
    let _ = foo(); 
}

resulting in

error[E0425]: cannot find type `Name` in this scope
 --> src/main.rs:1:24
  |
1 | fn foo() -> Result<(), Name> {
  |                        ^^^^ not found in this scope
  |
help: consider importing one of these items
  |
1 + use hyper_util::client::legacy::connect::dns::Name;
  |
1 + use mime::Name;
  |
1 + use reqwest::dns::Name;
  |
1 + use reqwest_0_12_28::dns::Name;
  |
  = and 2 other candidates

because of the crates available to the playground, in a project with no Name anywhere the output would be

error[E0425]: cannot find type `Name` in this scope
 --> src/main.rs:1:24
  |
1 | fn foo() -> Result<(), Name> {
  |                        ^^^^ not found in this scope
  |
help: you might be missing a type parameter
  |
1 | fn foo<Name>() -> Result<(), AnUniexistentName> {
  |       ++++++

The case in the original report was more specific about one where bar does return a Result<_, some::path::to::Error>, but the logic to improve that one is pretty much the same as one that doesn't care about the names involved.