Skip to content

Commit c94fef2

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 e3b17cf commit c94fef2

9 files changed

+117
-119
lines changed

‎compiler/rustc_hir_typeck/src/coercion.rs

Lines changed: 10 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -1991,39 +1991,26 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> {
19911991
}
19921992
};
19931993

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

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

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

Lines changed: 67 additions & 75 deletions
Original file line numberDiff line numberDiff line change
@@ -33,7 +33,7 @@ use rustc_middle::ty::{GenericArgKind, GenericArgsRef, UserArgs, UserSelfTy};
3333
use rustc_session::lint;
3434
use rustc_span::def_id::LocalDefId;
3535
use rustc_span::hygiene::DesugaringKind;
36-
use rustc_span::symbol::{kw, sym, Ident};
36+
use rustc_span::symbol::{kw, sym};
3737
use rustc_span::Span;
3838
use rustc_target::abi::FieldIdx;
3939
use rustc_trait_selection::traits::error_reporting::TypeErrCtxtExt as _;
@@ -936,76 +936,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
936936
)
937937
}
938938

939-
/// Given a function `Node`, return its `HirId` and `FnDecl` if it exists. Given a closure
940-
/// that is the child of a function, return that function's `HirId` and `FnDecl` instead.
941-
/// This may seem confusing at first, but this is used in diagnostics for `async fn`,
942-
/// for example, where most of the type checking actually happens within a nested closure,
943-
/// but we often want access to the parent function's signature.
944-
///
945-
/// Otherwise, return false.
946-
pub(in super::super) fn get_node_fn_decl(
947-
&self,
948-
node: Node<'tcx>,
949-
) -> Option<(LocalDefId, &'tcx hir::FnDecl<'tcx>, Ident, bool)> {
950-
match node {
951-
Node::Item(&hir::Item {
952-
ident,
953-
kind: hir::ItemKind::Fn(ref sig, ..),
954-
owner_id,
955-
..
956-
}) => {
957-
// This is less than ideal, it will not suggest a return type span on any
958-
// method called `main`, regardless of whether it is actually the entry point,
959-
// but it will still present it as the reason for the expected type.
960-
Some((owner_id.def_id, &sig.decl, ident, ident.name != sym::main))
961-
}
962-
Node::TraitItem(&hir::TraitItem {
963-
ident,
964-
kind: hir::TraitItemKind::Fn(ref sig, ..),
965-
owner_id,
966-
..
967-
}) => Some((owner_id.def_id, &sig.decl, ident, true)),
968-
Node::ImplItem(&hir::ImplItem {
969-
ident,
970-
kind: hir::ImplItemKind::Fn(ref sig, ..),
971-
owner_id,
972-
..
973-
}) => Some((owner_id.def_id, &sig.decl, ident, false)),
974-
Node::Expr(&hir::Expr {
975-
hir_id,
976-
kind:
977-
hir::ExprKind::Closure(hir::Closure {
978-
kind: hir::ClosureKind::Coroutine(..), ..
979-
}),
980-
..
981-
}) => {
982-
let (ident, sig, owner_id) = match self.tcx.parent_hir_node(hir_id) {
983-
Node::Item(&hir::Item {
984-
ident,
985-
kind: hir::ItemKind::Fn(ref sig, ..),
986-
owner_id,
987-
..
988-
}) => (ident, sig, owner_id),
989-
Node::TraitItem(&hir::TraitItem {
990-
ident,
991-
kind: hir::TraitItemKind::Fn(ref sig, ..),
992-
owner_id,
993-
..
994-
}) => (ident, sig, owner_id),
995-
Node::ImplItem(&hir::ImplItem {
996-
ident,
997-
kind: hir::ImplItemKind::Fn(ref sig, ..),
998-
owner_id,
999-
..
1000-
}) => (ident, sig, owner_id),
1001-
_ => return None,
1002-
};
1003-
Some((owner_id.def_id, &sig.decl, ident, ident.name != sym::main))
1004-
}
1005-
_ => None,
1006-
}
1007-
}
1008-
1009939
/// Given a `HirId`, return the `HirId` of the enclosing function, its `FnDecl`, and whether a
1010940
/// suggestion can be made, `None` otherwise.
1011941
pub fn get_fn_decl(
@@ -1014,10 +944,72 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
1014944
) -> Option<(LocalDefId, &'tcx hir::FnDecl<'tcx>, bool)> {
1015945
// Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
1016946
// `while` before reaching it, as block tail returns are not available in them.
1017-
self.tcx.hir().get_fn_id_for_return_block(blk_id).and_then(|blk_id| {
1018-
let parent = self.tcx.hir_node(blk_id);
1019-
self.get_node_fn_decl(parent)
1020-
.map(|(fn_id, fn_decl, _, is_main)| (fn_id, fn_decl, is_main))
947+
self.tcx.hir().get_fn_id_for_return_block(blk_id).and_then(|item_id| {
948+
match self.tcx.hir_node(item_id) {
949+
Node::Item(&hir::Item {
950+
ident,
951+
kind: hir::ItemKind::Fn(ref sig, ..),
952+
owner_id,
953+
..
954+
}) => {
955+
// This is less than ideal, it will not suggest a return type span on any
956+
// method called `main`, regardless of whether it is actually the entry point,
957+
// but it will still present it as the reason for the expected type.
958+
Some((owner_id.def_id, sig.decl, ident.name != sym::main))
959+
}
960+
Node::TraitItem(&hir::TraitItem {
961+
kind: hir::TraitItemKind::Fn(ref sig, ..),
962+
owner_id,
963+
..
964+
}) => Some((owner_id.def_id, sig.decl, true)),
965+
// FIXME: Suggestable if this is not a trait implementation
966+
Node::ImplItem(&hir::ImplItem {
967+
kind: hir::ImplItemKind::Fn(ref sig, ..),
968+
owner_id,
969+
..
970+
}) => Some((owner_id.def_id, sig.decl, false)),
971+
Node::Expr(&hir::Expr {
972+
hir_id,
973+
kind: hir::ExprKind::Closure(&hir::Closure { def_id, kind, fn_decl, .. }),
974+
..
975+
}) => {
976+
match kind {
977+
hir::ClosureKind::CoroutineClosure(_) => {
978+
// FIXME(async_closures): Implement this.
979+
return None;
980+
}
981+
hir::ClosureKind::Coroutine(hir::CoroutineKind::Desugared(
982+
_,
983+
hir::CoroutineSource::Fn,
984+
)) => {
985+
let (ident, sig, owner_id) = match self.tcx.parent_hir_node(hir_id) {
986+
Node::Item(&hir::Item {
987+
ident,
988+
kind: hir::ItemKind::Fn(ref sig, ..),
989+
owner_id,
990+
..
991+
}) => (ident, sig, owner_id),
992+
Node::TraitItem(&hir::TraitItem {
993+
ident,
994+
kind: hir::TraitItemKind::Fn(ref sig, ..),
995+
owner_id,
996+
..
997+
}) => (ident, sig, owner_id),
998+
Node::ImplItem(&hir::ImplItem {
999+
ident,
1000+
kind: hir::ImplItemKind::Fn(ref sig, ..),
1001+
owner_id,
1002+
..
1003+
}) => (ident, sig, owner_id),
1004+
_ => return None,
1005+
};
1006+
Some((owner_id.def_id, sig.decl, ident.name != sym::main))
1007+
}
1008+
_ => Some((def_id, fn_decl, true)),
1009+
}
1010+
}
1011+
_ => None,
1012+
}
10211013
})
10221014
}
10231015

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

Lines changed: 7 additions & 0 deletions
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

Lines changed: 3 additions & 0 deletions
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

Lines changed: 3 additions & 0 deletions
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

Lines changed: 3 additions & 1 deletion
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

Lines changed: 1 addition & 0 deletions
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

Lines changed: 12 additions & 5 deletions
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

Lines changed: 11 additions & 15 deletions
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)