Suggest alternative return type for `Option`s and `Result`s

[llogiq]

Given the following code:

fn main() {
    let _ = vec[1].iter().next()?;
    Some(())
}

Rust reports an error for using ? and suggests adding ; after the Some(()). A preferrable Option (pun intended) is to suggest changing the return type to Option<()> when the body's result type is Option<_> and there exists at least one ? in the body. Similarly, if we have Results, we might want to try to infer a useful return type, e.g.

fn main() {
    let _ = std::fs::File::open("foo.txt")?;
    Ok(())
}

cc @estebank (diagnostics)

[estebank]

Notice that if the function is not main and there's no explicit return type we do suggest changing the return type:

error[E0308]: mismatched types
 --> src/lib.rs:3:5
  |
3 |     Ok(())
  |     ^^^^^^ expected (), found enum `std::result::Result`
  |
  = note: expected type `()`
             found type `std::result::Result<(), _>`
help: try adding a semicolon
  |
3 |     Ok(());
  |           ^
help: try adding a return type
  |
1 | fn foo() -> std::result::Result<(), _> {
  |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

[llogiq]

Can you tell me the rough location of the code that does this? I imagine it'll be easy enough to change or remove the main special case.

[estebank]

rust/src/librustc_typeck/check/mod.rs

Lines 3858 to 3915 in f0c2bdf

	/// A possible error is to forget to add a return type that is needed:
	///
	/// ```
	/// fn foo() {
	/// bar_that_returns_u32()
	/// }
	/// ```
	///
	/// This routine checks if the return type is left as default, the method is not part of an
	/// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
	/// type.
	fn suggest_missing_return_type(
	&self,
	err: &mut DiagnosticBuilder<'tcx>,
	fn_decl: &hir::FnDecl,
	expected: Ty<'tcx>,
	found: Ty<'tcx>,
	can_suggest: bool,
	) -> bool {
	// Only suggest changing the return type for methods that
	// haven't set a return type at all (and aren't `fn main()` or an impl).
	match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
	(&hir::FunctionRetTy::DefaultReturn(span), true, true, true) => {
	err.span_suggestion(
	span,
	"try adding a return type",
	format!("-> {} ", self.resolve_type_vars_with_obligations(found)),
	Applicability::MachineApplicable);
	true
	}
	(&hir::FunctionRetTy::DefaultReturn(span), false, true, true) => {
	err.span_label(span, "possibly return type missing here?");
	true
	}
	(&hir::FunctionRetTy::DefaultReturn(span), _, false, true) => {
	// `fn main()` must return `()`, do not suggest changing return type
	err.span_label(span, "expected `()` because of default return type");
	true
	}
	// expectation was caused by something else, not the default return
	(&hir::FunctionRetTy::DefaultReturn(_), _, _, false) => false,
	(&hir::FunctionRetTy::Return(ref ty), _, _, _) => {
	// Only point to return type if the expected type is the return type, as if they
	// are not, the expectation must have been caused by something else.
	debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.node);
	let sp = ty.span;
	let ty = AstConv::ast_ty_to_ty(self, ty);
	debug!("suggest_missing_return_type: return type {:?}", ty);
	debug!("suggest_missing_return_type: expected type {:?}", ty);
	if ty.sty == expected.sty {
	err.span_label(sp, format!("expected `{}` because of return type",
	expected));
	return true;
	}
	false
	}
	}
	}

rust/src/librustc_typeck/check/mod.rs

Lines 3729 to 3738 in f0c2bdf

	/// Given a `HirId`, return the `FnDecl` of the method it is enclosed by and whether a
	/// suggestion can be made, `None` otherwise.
	pub fn get_fn_decl(&self, blk_id: hir::HirId) -> Option<(&'tcx hir::FnDecl, bool)> {
	// Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
	// `while` before reaching it, as block tail returns are not available in them.
	self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
	let parent = self.tcx.hir().get_by_hir_id(blk_id);
	self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
	})
	}

rust/src/librustc_typeck/check/mod.rs

Lines 3707 to 3714 in f0c2bdf

	Node::Item(&hir::Item {
	ident, node: hir::ItemKind::Fn(ref decl, ..), ..
	}) => {
	// This is less than ideal, it will not suggest a return type span on any
	// method called `main`, regardless of whether it is actually the entry point,
	// but it will still present it as the reason for the expected type.
	Some((decl, ident, ident.name != sym::main))
	}

You'll probably have to add some differentiation between ident.name != sym::main and being an impl item.

[llogiq]

So in rust/src/librustc_typeck/check/mod.rs, line 3893 and following wouldn't it suffice to check if the expected type matches Result<(), _> and issue the suggestion in that case?