Skip to content

Commit 3d39101

Browse files
Dylan-DPCDylan-DPC
authored
Rollup merge of rust-lang#106583 - estebank:suggest-result-coercion, r=compiler-errors
Suggest coercion of `Result` using `?` Fix rust-lang#47560.
2 parents 1e61d73 + 62aff3b commit 3d39101

7 files changed

+237
-1
lines changed

‎compiler/rustc_hir_typeck/src/coercion.rs

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1619,6 +1619,7 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> {
16191619
}
16201620
}
16211621
}
1622+
16221623
fn note_unreachable_loop_return(
16231624
&self,
16241625
err: &mut Diagnostic,

‎compiler/rustc_hir_typeck/src/demand.rs

Lines changed: 52 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -59,7 +59,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
5959
|| self.suggest_copied_or_cloned(err, expr, expr_ty, expected)
6060
|| self.suggest_clone_for_ref(err, expr, expr_ty, expected)
6161
|| self.suggest_into(err, expr, expr_ty, expected)
62-
|| self.suggest_floating_point_literal(err, expr, expected);
62+
|| self.suggest_floating_point_literal(err, expr, expected)
63+
|| self.note_result_coercion(err, expr, expected, expr_ty);
6364
if !suggested {
6465
self.point_at_expr_source_of_inferred_type(err, expr, expr_ty, expected);
6566
}
@@ -697,6 +698,56 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
697698
);
698699
}
699700

701+
pub(crate) fn note_result_coercion(
702+
&self,
703+
err: &mut Diagnostic,
704+
expr: &hir::Expr<'tcx>,
705+
expected: Ty<'tcx>,
706+
found: Ty<'tcx>,
707+
) -> bool {
708+
let ty::Adt(e, substs_e) = expected.kind() else { return false; };
709+
let ty::Adt(f, substs_f) = found.kind() else { return false; };
710+
if e.did() != f.did() {
711+
return false;
712+
}
713+
if Some(e.did()) != self.tcx.get_diagnostic_item(sym::Result) {
714+
return false;
715+
}
716+
let map = self.tcx.hir();
717+
if let Some(hir::Node::Expr(expr)) = map.find_parent(expr.hir_id)
718+
&& let hir::ExprKind::Ret(_) = expr.kind
719+
{
720+
// `return foo;`
721+
} else if map.get_return_block(expr.hir_id).is_some() {
722+
// Function's tail expression.
723+
} else {
724+
return false;
725+
}
726+
let e = substs_e.type_at(1);
727+
let f = substs_f.type_at(1);
728+
if self
729+
.infcx
730+
.type_implements_trait(
731+
self.tcx.get_diagnostic_item(sym::Into).unwrap(),
732+
[f, e],
733+
self.param_env,
734+
)
735+
.must_apply_modulo_regions()
736+
{
737+
err.multipart_suggestion(
738+
"use `?` to coerce and return an appropriate `Err`, and wrap the resulting value \
739+
in `Ok` so the expression remains of type `Result`",
740+
vec![
741+
(expr.span.shrink_to_lo(), "Ok(".to_string()),
742+
(expr.span.shrink_to_hi(), "?)".to_string()),
743+
],
744+
Applicability::MaybeIncorrect,
745+
);
746+
return true;
747+
}
748+
false
749+
}
750+
700751
/// If the expected type is an enum (Issue #55250) with any variants whose
701752
/// sole field is of the found type, suggest such variants. (Issue #42764)
702753
fn suggest_compatible_variants(

‎tests/ui/type/type-check/coerce-result-return-value-2.rs

Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
struct A;
2+
struct B;
3+
impl From<A> for B {
4+
fn from(_: A) -> Self { B }
5+
}
6+
fn foo4(x: Result<(), A>) -> Result<(), B> {
7+
match true {
8+
true => x, //~ ERROR mismatched types
9+
false => x,
10+
}
11+
}
12+
fn foo5(x: Result<(), A>) -> Result<(), B> {
13+
match true {
14+
true => return x, //~ ERROR mismatched types
15+
false => return x,
16+
}
17+
}
18+
fn main() {
19+
let _ = foo4(Ok(()));
20+
let _ = foo5(Ok(()));
21+
let _: Result<(), B> = { //~ ERROR mismatched types
22+
Err(A);
23+
};
24+
}

‎tests/ui/type/type-check/coerce-result-return-value-2.stderr

Lines changed: 47 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,47 @@
1+
error[E0308]: mismatched types
2+
--> $DIR/coerce-result-return-value-2.rs:8:17
3+
|
4+
LL | fn foo4(x: Result<(), A>) -> Result<(), B> {
5+
| ------------- expected `Result<(), B>` because of return type
6+
LL | match true {
7+
LL | true => x,
8+
| ^ expected struct `B`, found struct `A`
9+
|
10+
= note: expected enum `Result<_, B>`
11+
found enum `Result<_, A>`
12+
help: use `?` to coerce and return an appropriate `Err`, and wrap the resulting value in `Ok` so the expression remains of type `Result`
13+
|
14+
LL | true => Ok(x?),
15+
| +++ ++
16+
17+
error[E0308]: mismatched types
18+
--> $DIR/coerce-result-return-value-2.rs:14:24
19+
|
20+
LL | fn foo5(x: Result<(), A>) -> Result<(), B> {
21+
| ------------- expected `Result<(), B>` because of return type
22+
LL | match true {
23+
LL | true => return x,
24+
| ^ expected struct `B`, found struct `A`
25+
|
26+
= note: expected enum `Result<_, B>`
27+
found enum `Result<_, A>`
28+
help: use `?` to coerce and return an appropriate `Err`, and wrap the resulting value in `Ok` so the expression remains of type `Result`
29+
|
30+
LL | true => return Ok(x?),
31+
| +++ ++
32+
33+
error[E0308]: mismatched types
34+
--> $DIR/coerce-result-return-value-2.rs:21:28
35+
|
36+
LL | let _: Result<(), B> = {
37+
| ____________________________^
38+
LL | | Err(A);
39+
LL | | };
40+
| |_____^ expected enum `Result`, found `()`
41+
|
42+
= note: expected enum `Result<(), B>`
43+
found unit type `()`
44+
45+
error: aborting due to 3 previous errors
46+
47+
For more information about this error, try `rustc --explain E0308`.

‎tests/ui/type/type-check/coerce-result-return-value.fixed

Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
// run-rustfix
2+
struct A;
3+
struct B;
4+
impl From<A> for B {
5+
fn from(_: A) -> Self { B }
6+
}
7+
fn foo1(x: Result<(), A>) -> Result<(), B> {
8+
Ok(x?) //~ ERROR mismatched types
9+
}
10+
fn foo2(x: Result<(), A>) -> Result<(), B> {
11+
return Ok(x?); //~ ERROR mismatched types
12+
}
13+
fn foo3(x: Result<(), A>) -> Result<(), B> {
14+
if true {
15+
Ok(x?) //~ ERROR mismatched types
16+
} else {
17+
Ok(x?) //~ ERROR mismatched types
18+
}
19+
}
20+
fn main() {
21+
let _ = foo1(Ok(()));
22+
let _ = foo2(Ok(()));
23+
let _ = foo3(Ok(()));
24+
}

‎tests/ui/type/type-check/coerce-result-return-value.rs

Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
// run-rustfix
2+
struct A;
3+
struct B;
4+
impl From<A> for B {
5+
fn from(_: A) -> Self { B }
6+
}
7+
fn foo1(x: Result<(), A>) -> Result<(), B> {
8+
x //~ ERROR mismatched types
9+
}
10+
fn foo2(x: Result<(), A>) -> Result<(), B> {
11+
return x; //~ ERROR mismatched types
12+
}
13+
fn foo3(x: Result<(), A>) -> Result<(), B> {
14+
if true {
15+
x //~ ERROR mismatched types
16+
} else {
17+
x //~ ERROR mismatched types
18+
}
19+
}
20+
fn main() {
21+
let _ = foo1(Ok(()));
22+
let _ = foo2(Ok(()));
23+
let _ = foo3(Ok(()));
24+
}

‎tests/ui/type/type-check/coerce-result-return-value.stderr

Lines changed: 65 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,65 @@
1+
error[E0308]: mismatched types
2+
--> $DIR/coerce-result-return-value.rs:8:5
3+
|
4+
LL | fn foo1(x: Result<(), A>) -> Result<(), B> {
5+
| ------------- expected `Result<(), B>` because of return type
6+
LL | x
7+
| ^ expected struct `B`, found struct `A`
8+
|
9+
= note: expected enum `Result<_, B>`
10+
found enum `Result<_, A>`
11+
help: use `?` to coerce and return an appropriate `Err`, and wrap the resulting value in `Ok` so the expression remains of type `Result`
12+
|
13+
LL | Ok(x?)
14+
| +++ ++
15+
16+
error[E0308]: mismatched types
17+
--> $DIR/coerce-result-return-value.rs:11:12
18+
|
19+
LL | fn foo2(x: Result<(), A>) -> Result<(), B> {
20+
| ------------- expected `Result<(), B>` because of return type
21+
LL | return x;
22+
| ^ expected struct `B`, found struct `A`
23+
|
24+
= note: expected enum `Result<_, B>`
25+
found enum `Result<_, A>`
26+
help: use `?` to coerce and return an appropriate `Err`, and wrap the resulting value in `Ok` so the expression remains of type `Result`
27+
|
28+
LL | return Ok(x?);
29+
| +++ ++
30+
31+
error[E0308]: mismatched types
32+
--> $DIR/coerce-result-return-value.rs:15:9
33+
|
34+
LL | fn foo3(x: Result<(), A>) -> Result<(), B> {
35+
| ------------- expected `Result<(), B>` because of return type
36+
LL | if true {
37+
LL | x
38+
| ^ expected struct `B`, found struct `A`
39+
|
40+
= note: expected enum `Result<_, B>`
41+
found enum `Result<_, A>`
42+
help: use `?` to coerce and return an appropriate `Err`, and wrap the resulting value in `Ok` so the expression remains of type `Result`
43+
|
44+
LL | Ok(x?)
45+
| +++ ++
46+
47+
error[E0308]: mismatched types
48+
--> $DIR/coerce-result-return-value.rs:17:9
49+
|
50+
LL | fn foo3(x: Result<(), A>) -> Result<(), B> {
51+
| ------------- expected `Result<(), B>` because of return type
52+
...
53+
LL | x
54+
| ^ expected struct `B`, found struct `A`
55+
|
56+
= note: expected enum `Result<_, B>`
57+
found enum `Result<_, A>`
58+
help: use `?` to coerce and return an appropriate `Err`, and wrap the resulting value in `Ok` so the expression remains of type `Result`
59+
|
60+
LL | Ok(x?)
61+
| +++ ++
62+
63+
error: aborting due to 4 previous errors
64+
65+
For more information about this error, try `rustc --explain E0308`.

0 commit comments

Comments
 (0)