Skip to content

Commit 6c3879d

Browse files
estebankestebank
committed
Provide context when ? can't be called because of Result<_, E>
When a method chain ending in `?` causes an E0277 because the expression's `Result::Err` variant doesn't have a type that can be converted to the `Result<_, E>` type parameter in the return type, provide additional context of which parts of the chain can and can't support the `?` operator. ``` error[E0277]: `?` couldn't convert the error to `String` --> $DIR/question-mark-result-err-mismatch.rs:28:25 | LL | fn bar() -> Result<(), String> { | ------------------ expected `String` because of this LL | let x = foo(); | ----- this can be annotated with `?` because it has type `Result<String, String>` LL | let one = x LL | .map(|s| ()) | ----------- this can be annotated with `?` because it has type `Result<(), String>` LL | .map_err(|_| ())?; | ---------------^ the trait `From<()>` is not implemented for `String` | | | this can't be annotated with `?` because it has type `Result<(), ()>` | = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait = help: the following other types implement trait `From<T>`: <String as From<char>> <String as From<Box<str>>> <String as From<Cow<'a, str>>> <String as From<&str>> <String as From<&mut str>> <String as From<&String>> = note: required for `Result<(), String>` to implement `FromResidual<Result<Infallible, ()>>` ``` Fix #72124.
1 parent ec94480 commit 6c3879d

File tree

6 files changed

+294
-4
lines changed

6 files changed

+294
-4
lines changed

‎compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs‎

Lines changed: 143 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,7 @@ use super::suggestions::{get_explanation_based_on_obligation, TypeErrCtxtExt as
33
use crate::errors::{ClosureFnMutLabel, ClosureFnOnceLabel, ClosureKindMismatch};
44
use crate::infer::error_reporting::{TyCategory, TypeAnnotationNeeded as ErrorCode};
55
use crate::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
6+
use crate::infer::InferCtxtExt as _;
67
use crate::infer::{self, InferCtxt};
78
use crate::traits::error_reporting::infer_ctxt_ext::InferCtxtExt;
89
use crate::traits::error_reporting::{ambiguity, ambiguity::Ambiguity::*};
@@ -40,7 +41,7 @@ use rustc_session::config::{DumpSolverProofTree, TraitSolver};
4041
use rustc_session::Limit;
4142
use rustc_span::def_id::LOCAL_CRATE;
4243
use rustc_span::symbol::sym;
43-
use rustc_span::{ExpnKind, Span, DUMMY_SP};
44+
use rustc_span::{BytePos, ExpnKind, Span, DUMMY_SP};
4445
use std::borrow::Cow;
4546
use std::fmt;
4647
use std::iter;
@@ -106,6 +107,13 @@ pub trait TypeErrCtxtExt<'tcx> {
106107

107108
fn fn_arg_obligation(&self, obligation: &PredicateObligation<'tcx>) -> bool;
108109

110+
fn try_conversion_context(
111+
&self,
112+
obligation: &PredicateObligation<'tcx>,
113+
trait_ref: ty::TraitRef<'tcx>,
114+
err: &mut Diagnostic,
115+
);
116+
109117
fn report_const_param_not_wf(
110118
&self,
111119
ty: Ty<'tcx>,
@@ -509,6 +517,10 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
509517

510518
let mut err = struct_span_err!(self.tcx.sess, span, E0277, "{}", err_msg);
511519

520+
if is_try_conversion {
521+
self.try_conversion_context(&obligation, trait_ref.skip_binder(), &mut err);
522+
}
523+
512524
if is_try_conversion && let Some(ret_span) = self.return_type_span(&obligation) {
513525
err.span_label(
514526
ret_span,
@@ -982,6 +994,136 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
982994
false
983995
}
984996

997+
/// When the `E` of the resulting `Result<T, E>` in an expression `foo().bar().baz()?`,
998+
/// identify thoe method chain sub-expressions that could or could not have been annotated
999+
/// with `?`.
1000+
fn try_conversion_context(
1001+
&self,
1002+
obligation: &PredicateObligation<'tcx>,
1003+
trait_ref: ty::TraitRef<'tcx>,
1004+
err: &mut Diagnostic,
1005+
) {
1006+
let span = obligation.cause.span;
1007+
struct V<'v> {
1008+
search_span: Span,
1009+
found: Option<&'v hir::Expr<'v>>,
1010+
}
1011+
impl<'v> Visitor<'v> for V<'v> {
1012+
fn visit_expr(&mut self, ex: &'v hir::Expr<'v>) {
1013+
if let hir::ExprKind::Match(expr, _arms, hir::MatchSource::TryDesugar(_)) = ex.kind
1014+
{
1015+
if ex.span.with_lo(ex.span.hi() - BytePos(1)).source_equal(self.search_span) {
1016+
if let hir::ExprKind::Call(_, [expr, ..]) = expr.kind {
1017+
self.found = Some(expr);
1018+
return;
1019+
}
1020+
}
1021+
}
1022+
hir::intravisit::walk_expr(self, ex);
1023+
}
1024+
}
1025+
let hir_id = self.tcx.local_def_id_to_hir_id(obligation.cause.body_id);
1026+
let body_id = match self.tcx.hir().find(hir_id) {
1027+
Some(hir::Node::Item(hir::Item { kind: hir::ItemKind::Fn(_, _, body_id), .. })) => {
1028+
body_id
1029+
}
1030+
_ => return,
1031+
};
1032+
let mut v = V { search_span: span, found: None };
1033+
v.visit_body(self.tcx.hir().body(*body_id));
1034+
let Some(expr) = v.found else {
1035+
return;
1036+
};
1037+
let Some(typeck) = &self.typeck_results else {
1038+
return;
1039+
};
1040+
let Some((ObligationCauseCode::QuestionMark, Some(y))) = obligation.cause.code().parent()
1041+
else {
1042+
return;
1043+
};
1044+
if !self.tcx.is_diagnostic_item(sym::FromResidual, y.def_id()) {
1045+
return;
1046+
}
1047+
let self_ty = trait_ref.self_ty();
1048+
1049+
let mut prev_ty = self.resolve_vars_if_possible(
1050+
typeck.expr_ty_adjusted_opt(expr).unwrap_or(Ty::new_misc_error(self.tcx)),
1051+
);
1052+
let mut annotate_expr = |span: Span, prev_ty: Ty<'tcx>, self_ty: Ty<'tcx>| -> bool {
1053+
// We always look at the `E` type, because that's the only one affected by `?`. If the
1054+
// incorrect `Result<T, E>` is because of the `T`, we'll get an E0308 on the whole
1055+
// expression, after the `?` has "unwrapped" the `T`.
1056+
let ty::Adt(def, args) = prev_ty.kind() else {
1057+
return false;
1058+
};
1059+
let Some(arg) = args.get(1) else {
1060+
return false;
1061+
};
1062+
if !self.tcx.is_diagnostic_item(sym::Result, def.did()) {
1063+
return false;
1064+
}
1065+
let can = if self
1066+
.infcx
1067+
.type_implements_trait(
1068+
self.tcx.get_diagnostic_item(sym::From).unwrap(),
1069+
[self_ty.into(), *arg],
1070+
obligation.param_env,
1071+
)
1072+
.must_apply_modulo_regions()
1073+
{
1074+
"can"
1075+
} else {
1076+
"can't"
1077+
};
1078+
err.span_label(
1079+
span,
1080+
format!("this {can} be annotated with `?` because it has type `{prev_ty}`"),
1081+
);
1082+
true
1083+
};
1084+
1085+
// The following logic is simlar to `point_at_chain`, but that's focused on associated types
1086+
let mut expr = expr;
1087+
while let hir::ExprKind::MethodCall(_path_segment, rcvr_expr, _args, span) = expr.kind {
1088+
// Point at every method call in the chain with the `Result` type.
1089+
// let foo = bar.iter().map(mapper)?;
1090+
// ------ -----------
1091+
expr = rcvr_expr;
1092+
if !annotate_expr(span, prev_ty, self_ty) {
1093+
break;
1094+
}
1095+
1096+
prev_ty = self.resolve_vars_if_possible(
1097+
typeck.expr_ty_adjusted_opt(expr).unwrap_or(Ty::new_misc_error(self.tcx)),
1098+
);
1099+
1100+
if let hir::ExprKind::Path(hir::QPath::Resolved(None, path)) = expr.kind
1101+
&& let hir::Path { res: hir::def::Res::Local(hir_id), .. } = path
1102+
&& let Some(hir::Node::Pat(binding)) = self.tcx.hir().find(*hir_id)
1103+
&& let Some(parent) = self.tcx.hir().find_parent(binding.hir_id)
1104+
{
1105+
// We've reached the root of the method call chain...
1106+
if let hir::Node::Local(local) = parent
1107+
&& let Some(binding_expr) = local.init
1108+
{
1109+
// ...and it is a binding. Get the binding creation and continue the chain.
1110+
expr = binding_expr;
1111+
}
1112+
if let hir::Node::Param(_param) = parent {
1113+
// ...and it is a an fn argument.
1114+
break;
1115+
}
1116+
}
1117+
}
1118+
// `expr` is now the "root" expression of the method call chain, which can be any
1119+
// expression kind, like a method call or a path. If this expression is `Result<T, E>` as
1120+
// well, then we also point at it.
1121+
prev_ty = self.resolve_vars_if_possible(
1122+
typeck.expr_ty_adjusted_opt(expr).unwrap_or(Ty::new_misc_error(self.tcx)),
1123+
);
1124+
annotate_expr(expr.span, prev_ty, self_ty);
1125+
}
1126+
9851127
fn report_const_param_not_wf(
9861128
&self,
9871129
ty: Ty<'tcx>,

‎tests/ui/traits/question-mark-result-err-mismatch.rs‎

Lines changed: 59 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,59 @@
1+
fn foo() -> Result<String, String> { //~ NOTE expected `String` because of this
2+
let test = String::from("one,two");
3+
let x = test
4+
.split_whitespace()
5+
.next()
6+
.ok_or_else(|| { //~ NOTE this can be annotated with `?` because it has type `Result<&str, &str>`
7+
"Couldn't split the test string"
8+
});
9+
let one = x
10+
.map(|s| ()) //~ NOTE this can be annotated with `?` because it has type `Result<(), &str>`
11+
.map_err(|_| ()) //~ NOTE this can't be annotated with `?` because it has type `Result<(), ()>`
12+
.map(|()| "")?; //~ ERROR `?` couldn't convert the error to `String`
13+
//~^ NOTE in this expansion of desugaring of operator `?`
14+
//~| NOTE in this expansion of desugaring of operator `?`
15+
//~| NOTE in this expansion of desugaring of operator `?`
16+
//~| NOTE in this expansion of desugaring of operator `?`
17+
//~| NOTE this can't be annotated with `?` because it has type `Result<&str, ()>`
18+
//~| NOTE the trait `From<()>` is not implemented for `String`
19+
//~| NOTE the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
20+
//~| NOTE required for `Result<String, String>` to implement `FromResidual<Result<Infallible, ()>>`
21+
Ok(one.to_string())
22+
}
23+
24+
fn bar() -> Result<(), String> { //~ NOTE expected `String` because of this
25+
let x = foo(); //~ NOTE this can be annotated with `?` because it has type `Result<String, String>`
26+
let one = x
27+
.map(|s| ()) //~ NOTE this can be annotated with `?` because it has type `Result<(), String>`
28+
.map_err(|_| ())?; //~ ERROR `?` couldn't convert the error to `String`
29+
//~^ NOTE in this expansion of desugaring of operator `?`
30+
//~| NOTE in this expansion of desugaring of operator `?`
31+
//~| NOTE in this expansion of desugaring of operator `?`
32+
//~| NOTE in this expansion of desugaring of operator `?`
33+
//~| NOTE this can't be annotated with `?` because it has type `Result<(), ()>`
34+
//~| NOTE the trait `From<()>` is not implemented for `String`
35+
//~| NOTE the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
36+
//~| NOTE required for `Result<(), String>` to implement `FromResidual<Result<Infallible, ()>>`
37+
Ok(one)
38+
}
39+
40+
fn baz() -> Result<String, String> { //~ NOTE expected `String` because of this
41+
let test = String::from("one,two");
42+
let one = test
43+
.split_whitespace()
44+
.next()
45+
.ok_or_else(|| { //~ NOTE this can't be annotated with `?` because it has type `Result<&str, ()>`
46+
"Couldn't split the test string";
47+
})?;
48+
//~^ ERROR `?` couldn't convert the error to `String`
49+
//~| NOTE in this expansion of desugaring of operator `?`
50+
//~| NOTE in this expansion of desugaring of operator `?`
51+
//~| NOTE in this expansion of desugaring of operator `?`
52+
//~| NOTE in this expansion of desugaring of operator `?`
53+
//~| NOTE the trait `From<()>` is not implemented for `String`
54+
//~| NOTE the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
55+
//~| NOTE required for `Result<String, String>` to implement `FromResidual<Result<Infallible, ()>>`
56+
Ok(one.to_string())
57+
}
58+
59+
fn main() {}

‎tests/ui/traits/question-mark-result-err-mismatch.stderr‎

Lines changed: 83 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,83 @@
1+
error[E0277]: `?` couldn't convert the error to `String`
2+
--> $DIR/question-mark-result-err-mismatch.rs:12:22
3+
|
4+
LL | fn foo() -> Result<String, String> {
5+
| ---------------------- expected `String` because of this
6+
...
7+
LL | .ok_or_else(|| {
8+
| __________-
9+
LL | | "Couldn't split the test string"
10+
LL | | });
11+
| |__________- this can be annotated with `?` because it has type `Result<&str, &str>`
12+
LL | let one = x
13+
LL | .map(|s| ())
14+
| ----------- this can be annotated with `?` because it has type `Result<(), &str>`
15+
LL | .map_err(|_| ())
16+
| --------------- this can't be annotated with `?` because it has type `Result<(), ()>`
17+
LL | .map(|()| "")?;
18+
| ------------^ the trait `From<()>` is not implemented for `String`
19+
| |
20+
| this can't be annotated with `?` because it has type `Result<&str, ()>`
21+
|
22+
= note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
23+
= help: the following other types implement trait `From<T>`:
24+
<String as From<char>>
25+
<String as From<Box<str>>>
26+
<String as From<Cow<'a, str>>>
27+
<String as From<&str>>
28+
<String as From<&mut str>>
29+
<String as From<&String>>
30+
= note: required for `Result<String, String>` to implement `FromResidual<Result<Infallible, ()>>`
31+
32+
error[E0277]: `?` couldn't convert the error to `String`
33+
--> $DIR/question-mark-result-err-mismatch.rs:28:25
34+
|
35+
LL | fn bar() -> Result<(), String> {
36+
| ------------------ expected `String` because of this
37+
LL | let x = foo();
38+
| ----- this can be annotated with `?` because it has type `Result<String, String>`
39+
LL | let one = x
40+
LL | .map(|s| ())
41+
| ----------- this can be annotated with `?` because it has type `Result<(), String>`
42+
LL | .map_err(|_| ())?;
43+
| ---------------^ the trait `From<()>` is not implemented for `String`
44+
| |
45+
| this can't be annotated with `?` because it has type `Result<(), ()>`
46+
|
47+
= note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
48+
= help: the following other types implement trait `From<T>`:
49+
<String as From<char>>
50+
<String as From<Box<str>>>
51+
<String as From<Cow<'a, str>>>
52+
<String as From<&str>>
53+
<String as From<&mut str>>
54+
<String as From<&String>>
55+
= note: required for `Result<(), String>` to implement `FromResidual<Result<Infallible, ()>>`
56+
57+
error[E0277]: `?` couldn't convert the error to `String`
58+
--> $DIR/question-mark-result-err-mismatch.rs:47:11
59+
|
60+
LL | fn baz() -> Result<String, String> {
61+
| ---------------------- expected `String` because of this
62+
...
63+
LL | .ok_or_else(|| {
64+
| __________-
65+
LL | | "Couldn't split the test string";
66+
LL | | })?;
67+
| | -^ the trait `From<()>` is not implemented for `String`
68+
| |__________|
69+
| this can't be annotated with `?` because it has type `Result<&str, ()>`
70+
|
71+
= note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
72+
= help: the following other types implement trait `From<T>`:
73+
<String as From<char>>
74+
<String as From<Box<str>>>
75+
<String as From<Cow<'a, str>>>
76+
<String as From<&str>>
77+
<String as From<&mut str>>
78+
<String as From<&String>>
79+
= note: required for `Result<String, String>` to implement `FromResidual<Result<Infallible, ()>>`
80+
81+
error: aborting due to 3 previous errors
82+
83+
For more information about this error, try `rustc --explain E0277`.

‎tests/ui/try-block/try-block-bad-type.stderr‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,9 @@ error[E0277]: `?` couldn't convert the error to `TryFromSliceError`
22
--> $DIR/try-block-bad-type.rs:7:16
33
|
44
LL | Err("")?;
5-
| ^ the trait `From<&str>` is not implemented for `TryFromSliceError`
5+
| -------^ the trait `From<&str>` is not implemented for `TryFromSliceError`
6+
| |
7+
| this can't be annotated with `?` because it has type `Result<_, &str>`
68
|
79
= note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
810
= help: the trait `From<Infallible>` is implemented for `TryFromSliceError`

‎tests/ui/try-trait/bad-interconversion.stderr‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,9 @@ error[E0277]: `?` couldn't convert the error to `u8`
44
LL | fn result_to_result() -> Result<u64, u8> {
55
| --------------- expected `u8` because of this
66
LL | Ok(Err(123_i32)?)
7-
| ^ the trait `From<i32>` is not implemented for `u8`
7+
| ------------^ the trait `From<i32>` is not implemented for `u8`
8+
| |
9+
| this can't be annotated with `?` because it has type `Result<_, i32>`
810
|
911
= note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
1012
= help: the following other types implement trait `From<T>`:

‎tests/ui/try-trait/issue-32709.stderr‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,9 @@ error[E0277]: `?` couldn't convert the error to `()`
44
LL | fn a() -> Result<i32, ()> {
55
| --------------- expected `()` because of this
66
LL | Err(5)?;
7-
| ^ the trait `From<{integer}>` is not implemented for `()`
7+
| ------^ the trait `From<{integer}>` is not implemented for `()`
8+
| |
9+
| this can't be annotated with `?` because it has type `Result<_, {integer}>`
810
|
911
= note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
1012
= help: the following other types implement trait `From<T>`:

0 commit comments

Comments
 (0)