Skip to content

Commit b2eadba

Browse files
compiler-errorscompiler-errors
committed
Inline get_node_fn_decl into get_fn_decl, simplify/explain logic in report_return_mismatched_types
1 parent 72768cd commit b2eadba

9 files changed

+117
-119
lines changed

‎compiler/rustc_hir_typeck/src/coercion.rs

+10-23
Original file line numberDiff line numberDiff line change
@@ -1994,39 +1994,26 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> {
19941994
}
19951995
};
19961996

1997+
// If this is due to an explicit `return`, suggest adding a return type.
19971998
if let Some((fn_id, fn_decl, can_suggest)) = fcx.get_fn_decl(parent_id)
19981999
&& !due_to_block
19992000
{
20002001
fcx.suggest_missing_return_type(&mut err, fn_decl, expected, found, can_suggest, fn_id);
20012002
}
20022003

2003-
let mut parent_id = fcx.tcx.hir().get_parent_item(block_or_return_id).def_id;
2004-
let mut parent_item = fcx.tcx.hir_node_by_def_id(parent_id);
2005-
// When suggesting return, we need to account for closures and async blocks, not just items.
2006-
// FIXME: fix get_fn_decl to be async block aware, use get_fn_decl results above
2007-
for (_, node) in fcx.tcx.hir().parent_iter(block_or_return_id) {
2008-
match node {
2009-
hir::Node::Expr(&hir::Expr {
2010-
kind: hir::ExprKind::Closure(hir::Closure { def_id, .. }),
2011-
..
2012-
}) => {
2013-
parent_item = node;
2014-
parent_id = *def_id;
2015-
break;
2016-
}
2017-
hir::Node::Item(_) | hir::Node::TraitItem(_) | hir::Node::ImplItem(_) => break,
2018-
_ => {}
2019-
}
2020-
}
2021-
2022-
if let Some(expr) = expression
2023-
&& let Some(fn_decl) = parent_item.fn_decl()
2024-
&& due_to_block
2004+
// If this is due to a block, then maybe we forgot a `return`/`break`.
2005+
if due_to_block
2006+
&& let Some(expr) = expression
2007+
&& let Some((parent_fn_decl, parent_id)) = fcx
2008+
.tcx
2009+
.hir()
2010+
.parent_iter(block_or_return_id)
2011+
.find_map(|(_, node)| Some((node.fn_decl()?, node.associated_body()?.0)))
20252012
{
20262013
fcx.suggest_missing_break_or_return_expr(
20272014
&mut err,
20282015
expr,
2029-
fn_decl,
2016+
parent_fn_decl,
20302017
expected,
20312018
found,
20322019
block_or_return_id,

‎compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

+67-75
Original file line numberDiff line numberDiff line change
@@ -32,7 +32,7 @@ use rustc_middle::ty::{GenericArgKind, GenericArgsRef, UserArgs, UserSelfTy};
3232
use rustc_session::lint;
3333
use rustc_span::def_id::LocalDefId;
3434
use rustc_span::hygiene::DesugaringKind;
35-
use rustc_span::symbol::{kw, sym, Ident};
35+
use rustc_span::symbol::{kw, sym};
3636
use rustc_span::Span;
3737
use rustc_target::abi::FieldIdx;
3838
use rustc_trait_selection::traits::error_reporting::TypeErrCtxtExt as _;
@@ -860,76 +860,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
860860
)
861861
}
862862

863-
/// Given a function `Node`, return its `HirId` and `FnDecl` if it exists. Given a closure
864-
/// that is the child of a function, return that function's `HirId` and `FnDecl` instead.
865-
/// This may seem confusing at first, but this is used in diagnostics for `async fn`,
866-
/// for example, where most of the type checking actually happens within a nested closure,
867-
/// but we often want access to the parent function's signature.
868-
///
869-
/// Otherwise, return false.
870-
pub(crate) fn get_node_fn_decl(
871-
&self,
872-
node: Node<'tcx>,
873-
) -> Option<(LocalDefId, &'tcx hir::FnDecl<'tcx>, Ident, bool)> {
874-
match node {
875-
Node::Item(&hir::Item {
876-
ident,
877-
kind: hir::ItemKind::Fn(ref sig, ..),
878-
owner_id,
879-
..
880-
}) => {
881-
// This is less than ideal, it will not suggest a return type span on any
882-
// method called `main`, regardless of whether it is actually the entry point,
883-
// but it will still present it as the reason for the expected type.
884-
Some((owner_id.def_id, &sig.decl, ident, ident.name != sym::main))
885-
}
886-
Node::TraitItem(&hir::TraitItem {
887-
ident,
888-
kind: hir::TraitItemKind::Fn(ref sig, ..),
889-
owner_id,
890-
..
891-
}) => Some((owner_id.def_id, &sig.decl, ident, true)),
892-
Node::ImplItem(&hir::ImplItem {
893-
ident,
894-
kind: hir::ImplItemKind::Fn(ref sig, ..),
895-
owner_id,
896-
..
897-
}) => Some((owner_id.def_id, &sig.decl, ident, false)),
898-
Node::Expr(&hir::Expr {
899-
hir_id,
900-
kind:
901-
hir::ExprKind::Closure(hir::Closure {
902-
kind: hir::ClosureKind::Coroutine(..), ..
903-
}),
904-
..
905-
}) => {
906-
let (ident, sig, owner_id) = match self.tcx.parent_hir_node(hir_id) {
907-
Node::Item(&hir::Item {
908-
ident,
909-
kind: hir::ItemKind::Fn(ref sig, ..),
910-
owner_id,
911-
..
912-
}) => (ident, sig, owner_id),
913-
Node::TraitItem(&hir::TraitItem {
914-
ident,
915-
kind: hir::TraitItemKind::Fn(ref sig, ..),
916-
owner_id,
917-
..
918-
}) => (ident, sig, owner_id),
919-
Node::ImplItem(&hir::ImplItem {
920-
ident,
921-
kind: hir::ImplItemKind::Fn(ref sig, ..),
922-
owner_id,
923-
..
924-
}) => (ident, sig, owner_id),
925-
_ => return None,
926-
};
927-
Some((owner_id.def_id, &sig.decl, ident, ident.name != sym::main))
928-
}
929-
_ => None,
930-
}
931-
}
932-
933863
/// Given a `HirId`, return the `HirId` of the enclosing function, its `FnDecl`, and whether a
934864
/// suggestion can be made, `None` otherwise.
935865
pub fn get_fn_decl(
@@ -938,10 +868,72 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
938868
) -> Option<(LocalDefId, &'tcx hir::FnDecl<'tcx>, bool)> {
939869
// Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
940870
// `while` before reaching it, as block tail returns are not available in them.
941-
self.tcx.hir().get_fn_id_for_return_block(blk_id).and_then(|blk_id| {
942-
let parent = self.tcx.hir_node(blk_id);
943-
self.get_node_fn_decl(parent)
944-
.map(|(fn_id, fn_decl, _, is_main)| (fn_id, fn_decl, is_main))
871+
self.tcx.hir().get_fn_id_for_return_block(blk_id).and_then(|item_id| {
872+
match self.tcx.hir_node(item_id) {
873+
Node::Item(&hir::Item {
874+
ident,
875+
kind: hir::ItemKind::Fn(ref sig, ..),
876+
owner_id,
877+
..
878+
}) => {
879+
// This is less than ideal, it will not suggest a return type span on any
880+
// method called `main`, regardless of whether it is actually the entry point,
881+
// but it will still present it as the reason for the expected type.
882+
Some((owner_id.def_id, sig.decl, ident.name != sym::main))
883+
}
884+
Node::TraitItem(&hir::TraitItem {
885+
kind: hir::TraitItemKind::Fn(ref sig, ..),
886+
owner_id,
887+
..
888+
}) => Some((owner_id.def_id, sig.decl, true)),
889+
// FIXME: Suggestable if this is not a trait implementation
890+
Node::ImplItem(&hir::ImplItem {
891+
kind: hir::ImplItemKind::Fn(ref sig, ..),
892+
owner_id,
893+
..
894+
}) => Some((owner_id.def_id, sig.decl, false)),
895+
Node::Expr(&hir::Expr {
896+
hir_id,
897+
kind: hir::ExprKind::Closure(&hir::Closure { def_id, kind, fn_decl, .. }),
898+
..
899+
}) => {
900+
match kind {
901+
hir::ClosureKind::CoroutineClosure(_) => {
902+
// FIXME(async_closures): Implement this.
903+
return None;
904+
}
905+
hir::ClosureKind::Coroutine(hir::CoroutineKind::Desugared(
906+
_,
907+
hir::CoroutineSource::Fn,
908+
)) => {
909+
let (ident, sig, owner_id) = match self.tcx.parent_hir_node(hir_id) {
910+
Node::Item(&hir::Item {
911+
ident,
912+
kind: hir::ItemKind::Fn(ref sig, ..),
913+
owner_id,
914+
..
915+
}) => (ident, sig, owner_id),
916+
Node::TraitItem(&hir::TraitItem {
917+
ident,
918+
kind: hir::TraitItemKind::Fn(ref sig, ..),
919+
owner_id,
920+
..
921+
}) => (ident, sig, owner_id),
922+
Node::ImplItem(&hir::ImplItem {
923+
ident,
924+
kind: hir::ImplItemKind::Fn(ref sig, ..),
925+
owner_id,
926+
..
927+
}) => (ident, sig, owner_id),
928+
_ => return None,
929+
};
930+
Some((owner_id.def_id, sig.decl, ident.name != sym::main))
931+
}
932+
_ => Some((def_id, fn_decl, true)),
933+
}
934+
}
935+
_ => None,
936+
}
945937
})
946938
}
947939

‎compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs

+7
Original file line numberDiff line numberDiff line change
@@ -799,6 +799,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
799799
can_suggest: bool,
800800
fn_id: LocalDefId,
801801
) -> bool {
802+
// Can't suggest `->` on a block-like coroutine
803+
if let Some(hir::CoroutineKind::Desugared(_, hir::CoroutineSource::Block)) =
804+
self.tcx.coroutine_kind(fn_id)
805+
{
806+
return false;
807+
}
808+
802809
let found =
803810
self.resolve_numeric_literals_with_default(self.resolve_vars_if_possible(found));
804811
// Only suggest changing the return type for methods that

‎tests/ui/async-await/dont-ice-for-type-mismatch-in-closure-in-async.stderr

+3
Original file line numberDiff line numberDiff line change
@@ -11,6 +11,9 @@ LL | | }
1111
error[E0308]: mismatched types
1212
--> $DIR/dont-ice-for-type-mismatch-in-closure-in-async.rs:12:9
1313
|
14+
LL | call(|| -> Option<()> {
15+
| ---------- expected `Option<()>` because of return type
16+
...
1417
LL | true
1518
| ^^^^ expected `Option<()>`, found `bool`
1619
|

‎tests/ui/closures/closure-return-type-mismatch.stderr

+3
Original file line numberDiff line numberDiff line change
@@ -13,6 +13,9 @@ LL | return "test";
1313
error[E0308]: mismatched types
1414
--> $DIR/closure-return-type-mismatch.rs:12:20
1515
|
16+
LL | || -> bool {
17+
| ---- expected `bool` because of return type
18+
LL | if false {
1619
LL | return "hello"
1720
| ^^^^^^^ expected `bool`, found `&str`
1821

‎tests/ui/impl-trait/issue-99914.stderr

+3-1
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,9 @@ error[E0308]: mismatched types
22
--> $DIR/issue-99914.rs:9:27
33
|
44
LL | t.and_then(|t| -> _ { bar(t) });
5-
| ^^^^^^ expected `Result<_, Error>`, found future
5+
| - ^^^^^^ expected `Result<_, Error>`, found future
6+
| |
7+
| expected `Result<_, Error>` because of return type
68
|
79
help: try wrapping the expression in `Ok`
810
|

‎tests/ui/suggestions/try-operator-dont-suggest-semicolon.rs

+1
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,7 @@
33

44
fn main() -> Result<(), ()> {
55
a(|| {
6+
//~^ HELP: try adding a return type
67
b()
78
//~^ ERROR: mismatched types [E0308]
89
//~| NOTE: expected `()`, found `i32`

‎tests/ui/suggestions/try-operator-dont-suggest-semicolon.stderr

+12-5
Original file line numberDiff line numberDiff line change
@@ -1,13 +1,20 @@
11
error[E0308]: mismatched types
2-
--> $DIR/try-operator-dont-suggest-semicolon.rs:6:9
2+
--> $DIR/try-operator-dont-suggest-semicolon.rs:7:9
33
|
44
LL | b()
5-
| ^^^- help: consider using a semicolon here: `;`
6-
| |
7-
| expected `()`, found `i32`
5+
| ^^^ expected `()`, found `i32`
6+
|
7+
help: consider using a semicolon here
8+
|
9+
LL | b();
10+
| +
11+
help: try adding a return type
12+
|
13+
LL | a(|| -> i32 {
14+
| ++++++
815

916
error[E0308]: mismatched types
10-
--> $DIR/try-operator-dont-suggest-semicolon.rs:16:9
17+
--> $DIR/try-operator-dont-suggest-semicolon.rs:17:9
1118
|
1219
LL | / if true {
1320
LL | |

‎tests/ui/typeck/issue-81943.stderr

+11-15
Original file line numberDiff line numberDiff line change
@@ -2,36 +2,32 @@ error[E0308]: mismatched types
22
--> $DIR/issue-81943.rs:7:9
33
|
44
LL | f(|x| lib::d!(x));
5-
| ^^^^^^^^^^ expected `()`, found `i32`
5+
| -^^^^^^^^^^ expected `()`, found `i32`
6+
| |
7+
| help: try adding a return type: `-> i32`
68
|
79
= note: this error originates in the macro `lib::d` (in Nightly builds, run with -Z macro-backtrace for more info)
810

911
error[E0308]: mismatched types
1012
--> $DIR/issue-81943.rs:8:28
1113
|
1214
LL | f(|x| match x { tmp => { g(tmp) } });
13-
| -------------------^^^^^^----
14-
| | |
15-
| | expected `()`, found `i32`
16-
| expected this to be `()`
15+
| ^^^^^^ expected `()`, found `i32`
1716
|
1817
help: consider using a semicolon here
1918
|
2019
LL | f(|x| match x { tmp => { g(tmp); } });
2120
| +
22-
help: consider using a semicolon here
21+
help: try adding a return type
2322
|
24-
LL | f(|x| match x { tmp => { g(tmp) } };);
25-
| +
23+
LL | f(|x| -> i32 match x { tmp => { g(tmp) } });
24+
| ++++++
2625

2726
error[E0308]: mismatched types
2827
--> $DIR/issue-81943.rs:10:38
2928
|
3029
LL | ($e:expr) => { match $e { x => { g(x) } } }
31-
| ------------------^^^^----
32-
| | |
33-
| | expected `()`, found `i32`
34-
| expected this to be `()`
30+
| ^^^^ expected `()`, found `i32`
3531
LL | }
3632
LL | f(|x| d!(x));
3733
| ----- in this macro invocation
@@ -41,10 +37,10 @@ help: consider using a semicolon here
4137
|
4238
LL | ($e:expr) => { match $e { x => { g(x); } } }
4339
| +
44-
help: consider using a semicolon here
40+
help: try adding a return type
4541
|
46-
LL | ($e:expr) => { match $e { x => { g(x) } }; }
47-
| +
42+
LL | f(|x| -> i32 d!(x));
43+
| ++++++
4844

4945
error: aborting due to 3 previous errors
5046

0 commit comments

Comments
 (0)