Improve error message on `Err` early returns that forgot the `return` keyword

[sdroege]

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

struct MyError;

fn foo(x: bool) -> Result<(), MyError> {
    if x {
        Err(MyError);
    }
    
    Ok(())
}

The current output is:

error[E0282]: type annotations needed
 --> src/main.rs:5:9
  |
5 |         Err(MyError);
  |         ^^^ cannot infer type for type parameter `T` declared on the enum `Result`

Ideally the output should look like:

error[E0282]: type annotations needed
 --> src/main.rs:5:9
  |
5 |         Err(MyError);
  |         ^^^ cannot infer type for type parameter `T` declared on the enum `Result`
help: try using `return` here:
  |
5 |         return Err(MyError);
  |         ^^^

[sdroege]

For the slightly modified case without the ; the compiler already gives a useful hint

error[E0308]: mismatched types
 --> src/main.rs:5:9
  |
4 | /     if x {
5 | |         Err(MyError)
  | |         ^^^^^^^^^^^^ expected `()`, found enum `Result`
6 | |     }
  | |_____- expected this to be `()`
  |
  = note: expected unit type `()`
                  found enum `Result<_, MyError>`
help: you might have meant to return this value
  |
5 |         return Err(MyError);
  |         ^^^^^^             ^

[m-ou-se]

For the slightly modified case without the ; the compiler already gives a useful hint

That suggestion is a special case of the mismatched types lint. The version with ; will need special casing on a very different lint, unfortunately.

When a type-mismatch occurs, this checks if the type matches the return type of the surrounding function:

rust/compiler/rustc_typeck/src/check/fn_ctxt/suggestions.rs

Lines 514 to 529 in cc9610b

	if let hir::FnRetTy::Return(ty) = fn_decl.output {
	let ty = <dyn AstConv<'_>>::ast_ty_to_ty(self, ty);
	let bound_vars = self.tcx.late_bound_vars(fn_id);
	let ty = self.tcx.erase_late_bound_regions(Binder::bind_with_vars(ty, bound_vars));
	let ty = self.normalize_associated_types_in(expr.span, ty);
	if self.can_coerce(found, ty) {
	err.multipart_suggestion(
	"you might have meant to return this value",
	vec![
	(expr.span.shrink_to_lo(), "return ".to_string()),
	(expr.span.shrink_to_hi(), ";".to_string()),
	],
	Applicability::MaybeIncorrect,
	);
	}
	}

For the 'type annotations needed' lint, I don't think we can apply the same logic.

We might also want a similar suggestion for unused_must_use, in cases where the type is fully known.

[inquisitivecrystal]

@rustbot label +D-confusing +D-newcomer-roadblock

[estebank]

Current output:

error[E0282]: type annotations needed
 --> f71.rs:5:9
  |
5 |         Err(MyError);
  |         ^^^ cannot infer type of the type parameter `T` declared on the enum `Result`
  |
help: consider specifying the generic arguments
  |
5 |         Err::<T, MyError>(MyError);
  |            ++++++++++++++

We still don't realize that you probably wanted to return this expression.