bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

When encountering unexpected closure return type, point at return type/expression

Browse source 
```
error[E0271]: expected `{closure@fallback-closure-wrap.rs:18:40}` to be a closure that returns `()`, but it returns `!`
  --> $DIR/fallback-closure-wrap.rs:19:9
   |
LL |     let error = Closure::wrap(Box::new(move || {
   |                                        -------
LL |         panic!("Can't connect to server.");
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `()`, found `!`
   |
   = note: expected unit type `()`
                   found type `!`
   = note: required for the cast from `Box<{closure@$DIR/fallback-closure-wrap.rs:18:40: 18:47}>` to `Box<dyn FnMut()>`
```

```
error[E0271]: expected `{closure@dont-ice-for-type-mismatch-in-closure-in-async.rs:6:10}` to be a closure that returns `bool`, but it returns `Option<()>`
  --> $DIR/dont-ice-for-type-mismatch-in-closure-in-async.rs:6:16
   |
LL |     call(|| -> Option<()> {
   |     ---- ------^^^^^^^^^^
   |     |          |
   |     |          expected `bool`, found `Option<()>`
   |     required by a bound introduced by this call
   |
   = note: expected type `bool`
              found enum `Option<()>`
note: required by a bound in `call`
  --> $DIR/dont-ice-for-type-mismatch-in-closure-in-async.rs:3:25
   |
LL | fn call(_: impl Fn() -> bool) {}
   |                         ^^^^ required by this bound in `call`
```

```
error[E0271]: expected `{closure@f670.rs:28:13}` to be a closure that returns `Result<(), _>`, but it returns `!`
    --> f670.rs:28:20
     |
28   |     let c = |e| -> ! {
     |             -------^
     |                    |
     |                    expected `Result<(), _>`, found `!`
...
32   |     f().or_else(c);
     |         ------- required by a bound introduced by this call
-Ztrack-diagnostics: created at compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs:1433:28
     |
     = note: expected enum `Result<(), _>`
                found type `!`
note: required by a bound in `Result::<T, E>::or_else`
    --> /home/gh-estebank/rust/library/core/src/result.rs:1406:39
     |
1406 |     pub fn or_else<F, O: FnOnce(E) -> Result<T, F>>(self, op: O) -> Result<T, F> {
     |                                       ^^^^^^^^^^^^ required by this bound in `Result::<T, E>::or_else`
```
This commit is contained in:
Esteban Küber 2024-10-25 21:27:13 +00:00
parent a6434ef9c0
commit d3a148fe07
11 changed files with 114 additions and 65 deletions
Download patch file Download diff file Expand all files Collapse all files

3
compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
View file

@ -642,6 +642,7 @@ pub(super) fn collect_return_position_impl_trait_in_trait_tys<'tcx>(
); );
let hir = tcx.hir(); let hir = tcx.hir();
infcx.err_ctxt().note_type_err( infcx.err_ctxt().note_type_err(
cause.span,
&mut diag, &mut diag,
&cause, &cause,
hir.get_if_local(impl_m.def_id) hir.get_if_local(impl_m.def_id)
@ -1061,6 +1062,7 @@ fn report_trait_method_mismatch<'tcx>(
cause.span = impl_err_span; cause.span = impl_err_span;
infcx.err_ctxt().note_type_err( infcx.err_ctxt().note_type_err(
cause.span,
&mut diag, &mut diag,
&cause, &cause,
trait_err_span.map(|sp| (sp, Cow::from("type in trait"), false)), trait_err_span.map(|sp| (sp, Cow::from("type in trait"), false)),
@ -1853,6 +1855,7 @@ fn compare_const_predicate_entailment<'tcx>(
}); });
infcx.err_ctxt().note_type_err( infcx.err_ctxt().note_type_err(
cause.span,
&mut diag, &mut diag,
&cause, &cause,
trait_c_span.map(|span| (span, Cow::from("type in trait"), false)), trait_c_span.map(|span| (span, Cow::from("type in trait"), false)),

1
compiler/rustc_hir_analysis/src/check/mod.rs
View file

@ -640,6 +640,7 @@ pub fn check_function_signature<'tcx>(
let failure_code = cause.as_failure_code_diag(err, cause.span, vec![]); let failure_code = cause.as_failure_code_diag(err, cause.span, vec![]);
let mut diag = tcx.dcx().create_err(failure_code); let mut diag = tcx.dcx().create_err(failure_code);
err_ctxt.note_type_err( err_ctxt.note_type_err(
cause.span,
&mut diag, &mut diag,
&cause, &cause,
None, None,

1
compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
View file

@ -1141,6 +1141,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let trace = mk_trace(provided_span, (formal_ty, expected_ty), provided_ty); let trace = mk_trace(provided_span, (formal_ty, expected_ty), provided_ty);
if let Some(e) = error { if let Some(e) = error {
self.err_ctxt().note_type_err( self.err_ctxt().note_type_err(
trace.cause.span,
&mut err, &mut err,
&trace.cause, &trace.cause,
None, None,

1
compiler/rustc_passes/src/check_attr.rs
View file

@ -2462,6 +2462,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
} }
infcx.err_ctxt().note_type_err( infcx.err_ctxt().note_type_err(
cause.span,
&mut diag, &mut diag,
&cause, &cause,
None, None,

4
compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
View file

@ -1386,6 +1386,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
#[instrument(level = "debug", skip(self, diag, secondary_span, prefer_label))] #[instrument(level = "debug", skip(self, diag, secondary_span, prefer_label))]
pub fn note_type_err( pub fn note_type_err(
&self, &self,
span: Span,
diag: &mut Diag<'_>, diag: &mut Diag<'_>,
cause: &ObligationCause<'tcx>, cause: &ObligationCause<'tcx>,
secondary_span: Option<(Span, Cow<'static, str>, bool)>, secondary_span: Option<(Span, Cow<'static, str>, bool)>,
@ -1393,8 +1394,6 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
terr: TypeError<'tcx>, terr: TypeError<'tcx>,
prefer_label: bool, prefer_label: bool,
) { ) {
let span = cause.span;
// For some types of errors, expected-found does not make // For some types of errors, expected-found does not make
// sense, so just ignore the values we were given. // sense, so just ignore the values we were given.
if let TypeError::CyclicTy(_) = terr { if let TypeError::CyclicTy(_) = terr {
@ -2053,6 +2052,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
); );
let mut diag = self.dcx().create_err(failure_code); let mut diag = self.dcx().create_err(failure_code);
self.note_type_err( self.note_type_err(
span,
&mut diag, &mut diag,
&trace.cause, &trace.cause,
None, None,

98
compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
View file

@ -702,6 +702,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
); );
self.note_type_err( self.note_type_err(
span,
&mut diag, &mut diag,
&obligation.cause, &obligation.cause,
None, None,
@ -931,14 +932,9 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
} }
} }
let hir_id = self.tcx.local_def_id_to_hir_id(obligation.cause.body_id); let hir_id = self.tcx.local_def_id_to_hir_id(obligation.cause.body_id);
let body_id = match self.tcx.hir_node(hir_id) { let Some(body_id) = self.tcx.hir_node(hir_id).body_id() else { return false };
hir::Node::Item(hir::Item { let ControlFlow::Break(expr) =
kind: hir::ItemKind::Fn { body: body_id, .. }, .. (FindMethodSubexprOfTry { search_span: span }).visit_body(self.tcx.hir().body(body_id))
}) => body_id,
_ => return false,
};
let ControlFlow::Break(expr) = (FindMethodSubexprOfTry { search_span: span })
.visit_body(self.tcx.hir().body(*body_id))
else { else {
return false; return false;
}; };
@ -1385,9 +1381,14 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
_ => (None, error.err), _ => (None, error.err),
}; };
let msg = values let (msg, span, closure_span) = values
.and_then(|(predicate, normalized_term, expected_term)| { .and_then(|(predicate, normalized_term, expected_term)| {
self.maybe_detailed_projection_msg(predicate, normalized_term, expected_term) self.maybe_detailed_projection_msg(
obligation.cause.span,
predicate,
normalized_term,
expected_term,
)
}) })
.unwrap_or_else(|| { .unwrap_or_else(|| {
let mut cx = FmtPrinter::new_with_limit( let mut cx = FmtPrinter::new_with_limit(
@ -1395,12 +1396,35 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
Namespace::TypeNS, Namespace::TypeNS,
rustc_session::Limit(10), rustc_session::Limit(10),
); );
with_forced_trimmed_paths!(format!("type mismatch resolving `{}`", { (
self.resolve_vars_if_possible(predicate).print(&mut cx).unwrap(); with_forced_trimmed_paths!(format!("type mismatch resolving `{}`", {
cx.into_buffer() self.resolve_vars_if_possible(predicate).print(&mut cx).unwrap();
})) cx.into_buffer()
})),
obligation.cause.span,
None,
)
}); });
let mut diag = struct_span_code_err!(self.dcx(), obligation.cause.span, E0271, "{msg}"); let mut diag = struct_span_code_err!(self.dcx(), span, E0271, "{msg}");
if let Some(span) = closure_span {
// Mark the closure decl so that it is seen even if we are pointing at the return
// type or expression.
//
// error[E0271]: expected `{closure@foo.rs:41:16}` to be a closure that returns
// `Unit3`, but it returns `Unit4`
// --> $DIR/foo.rs:43:17
// |
// LL | let v = Unit2.m(
// | - required by a bound introduced by this call
// ...
// LL | f: |x| {
// | --- /* this span */
// LL | drop(x);
// LL | Unit4
// | ^^^^^ expected `Unit3`, found `Unit4`
// |
diag.span_label(span, "");
}
let secondary_span = (|| { let secondary_span = (|| {
let ty::PredicateKind::Clause(ty::ClauseKind::Projection(proj)) = let ty::PredicateKind::Clause(ty::ClauseKind::Projection(proj)) =
@ -1460,6 +1484,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
})(); })();
self.note_type_err( self.note_type_err(
span,
&mut diag, &mut diag,
&obligation.cause, &obligation.cause,
secondary_span, secondary_span,
@ -1479,34 +1504,63 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
fn maybe_detailed_projection_msg( fn maybe_detailed_projection_msg(
&self, &self,
mut span: Span,
projection_term: ty::AliasTerm<'tcx>, projection_term: ty::AliasTerm<'tcx>,
normalized_ty: ty::Term<'tcx>, normalized_ty: ty::Term<'tcx>,
expected_ty: ty::Term<'tcx>, expected_ty: ty::Term<'tcx>,
) -> Option<String> { ) -> Option<(String, Span, Option<Span>)> {
let trait_def_id = projection_term.trait_def_id(self.tcx); let trait_def_id = projection_term.trait_def_id(self.tcx);
let self_ty = projection_term.self_ty(); let self_ty = projection_term.self_ty();
with_forced_trimmed_paths! { with_forced_trimmed_paths! {
if self.tcx.is_lang_item(projection_term.def_id, LangItem::FnOnceOutput) { if self.tcx.is_lang_item(projection_term.def_id, LangItem::FnOnceOutput) {
let fn_kind = self_ty.prefix_string(self.tcx); let fn_kind = self_ty.prefix_string(self.tcx);
let (span, closure_span) = if let ty::Closure(def_id, _) = self_ty.kind() {
let def_span = self.tcx.def_span(def_id);
let node = self.tcx.hir_node_by_def_id(def_id.as_local().unwrap());
if let Some(fn_decl) = node.fn_decl() {
span = match fn_decl.output {
hir::FnRetTy::Return(ty) => ty.span,
hir::FnRetTy::DefaultReturn(_) => {
let body = self.tcx.hir().body(node.body_id().unwrap());
match body.value.kind {
hir::ExprKind::Block(
hir::Block { expr: Some(expr), .. },
_,
) => expr.span,
hir::ExprKind::Block(
hir::Block {
expr: None, stmts: [.., last], ..
},
_,
) => last.span,
_ => body.value.span,
}
}
};
}
(span, Some(def_span))
} else {
(span, None)
};
let item = match self_ty.kind() { let item = match self_ty.kind() {
ty::FnDef(def, _) => self.tcx.item_name(*def).to_string(), ty::FnDef(def, _) => self.tcx.item_name(*def).to_string(),
_ => self_ty.to_string(), _ => self_ty.to_string(),
}; };
Some(format!( Some((format!(
"expected `{item}` to be a {fn_kind} that returns `{expected_ty}`, but it \ "expected `{item}` to be a {fn_kind} that returns `{expected_ty}`, but it \
returns `{normalized_ty}`", returns `{normalized_ty}`",
)) ), span, closure_span))
} else if self.tcx.is_lang_item(trait_def_id, LangItem::Future) { } else if self.tcx.is_lang_item(trait_def_id, LangItem::Future) {
Some(format!( Some((format!(
"expected `{self_ty}` to be a future that resolves to `{expected_ty}`, but it \ "expected `{self_ty}` to be a future that resolves to `{expected_ty}`, but it \
resolves to `{normalized_ty}`" resolves to `{normalized_ty}`"
)) ), span, None))
} else if Some(trait_def_id) == self.tcx.get_diagnostic_item(sym::Iterator) { } else if Some(trait_def_id) == self.tcx.get_diagnostic_item(sym::Iterator) {
Some(format!( Some((format!(
"expected `{self_ty}` to be an iterator that yields `{expected_ty}`, but it \ "expected `{self_ty}` to be an iterator that yields `{expected_ty}`, but it \
yields `{normalized_ty}`" yields `{normalized_ty}`"
)) ), span, None))
} else { } else {
None None
} }

17
tests/ui/async-await/dont-ice-for-type-mismatch-in-closure-in-async.stderr
View file

@ -21,18 +21,13 @@ LL | true
found type `bool` found type `bool`
error[E0271]: expected `{closure@dont-ice-for-type-mismatch-in-closure-in-async.rs:6:10}` to be a closure that returns `bool`, but it returns `Option<()>` error[E0271]: expected `{closure@dont-ice-for-type-mismatch-in-closure-in-async.rs:6:10}` to be a closure that returns `bool`, but it returns `Option<()>`
--> $DIR/dont-ice-for-type-mismatch-in-closure-in-async.rs:6:10 --> $DIR/dont-ice-for-type-mismatch-in-closure-in-async.rs:6:16
| |
LL | call(|| -> Option<()> { LL | call(|| -> Option<()> {
| _____----_^ | ---- ------^^^^^^^^^^
| | | | | |
| | required by a bound introduced by this call | | expected `bool`, found `Option<()>`
LL | | | required by a bound introduced by this call
LL | | if true {
LL | | false
... |
LL | | })
| |_____^ expected `bool`, found `Option<()>`
| |
= note: expected type `bool` = note: expected type `bool`
found enum `Option<()>` found enum `Option<()>`

6
tests/ui/higher-ranked/trait-bounds/issue-62203-hrtb-ice.rs
View file

@ -36,12 +36,10 @@ trait Ty<'a> {
fn main() { fn main() {
let v = Unit2.m( let v = Unit2.m(
L { L { //~ ERROR type mismatch
//~^ ERROR to be a closure that returns `Unit3`, but it returns `Unit4`
//~| ERROR type mismatch
f: |x| { f: |x| {
drop(x); drop(x);
Unit4 Unit4 //~ ERROR to be a closure that returns `Unit3`, but it returns `Unit4`
}, },
}, },
); );

33
tests/ui/higher-ranked/trait-bounds/issue-62203-hrtb-ice.stderr
View file

@ -1,16 +1,15 @@
error[E0271]: type mismatch resolving `<L<{closure@issue-62203-hrtb-ice.rs:42:16}> as T0<'r, (&u8,)>>::O == <_ as Ty<'r>>::V` error[E0271]: type mismatch resolving `<L<{closure@issue-62203-hrtb-ice.rs:40:16}> as T0<'r, (&u8,)>>::O == <_ as Ty<'r>>::V`
--> $DIR/issue-62203-hrtb-ice.rs:39:9 --> $DIR/issue-62203-hrtb-ice.rs:39:9
| |
LL | let v = Unit2.m( LL | let v = Unit2.m(
| - required by a bound introduced by this call | - required by a bound introduced by this call
LL | / L { LL | / L {
LL | |
LL | |
LL | | f: |x| { LL | | f: |x| {
... | LL | | drop(x);
LL | | Unit4
LL | | }, LL | | },
LL | | }, LL | | },
| |_________^ type mismatch resolving `<L<{closure@issue-62203-hrtb-ice.rs:42:16}> as T0<'r, (&u8,)>>::O == <_ as Ty<'r>>::V` | |_________^ type mismatch resolving `<L<{closure@issue-62203-hrtb-ice.rs:40:16}> as T0<'r, (&u8,)>>::O == <_ as Ty<'r>>::V`
| |
note: expected this to be `<_ as Ty<'_>>::V` note: expected this to be `<_ as Ty<'_>>::V`
--> $DIR/issue-62203-hrtb-ice.rs:21:14 --> $DIR/issue-62203-hrtb-ice.rs:21:14
@ -30,21 +29,19 @@ LL | where
LL | F: for<'r> T0<'r, (<Self as Ty<'r>>::V,), O = <B as Ty<'r>>::V>, LL | F: for<'r> T0<'r, (<Self as Ty<'r>>::V,), O = <B as Ty<'r>>::V>,
| ^^^^^^^^^^^^^^^^^^^^ required by this bound in `T1::m` | ^^^^^^^^^^^^^^^^^^^^ required by this bound in `T1::m`
error[E0271]: expected `{closure@issue-62203-hrtb-ice.rs:42:16}` to be a closure that returns `Unit3`, but it returns `Unit4` error[E0271]: expected `{closure@issue-62203-hrtb-ice.rs:40:16}` to be a closure that returns `Unit3`, but it returns `Unit4`
--> $DIR/issue-62203-hrtb-ice.rs:39:9 --> $DIR/issue-62203-hrtb-ice.rs:42:17
| |
LL | let v = Unit2.m( LL | let v = Unit2.m(
| - required by a bound introduced by this call | - required by a bound introduced by this call
LL | / L { LL | L {
LL | | LL | f: |x| {
LL | | | ---
LL | | f: |x| { LL | drop(x);
... | LL | Unit4
LL | | }, | ^^^^^ expected `Unit3`, found `Unit4`
LL | | },
| |_________^ expected `Unit3`, found `Unit4`
| |
note: required for `L<{closure@$DIR/issue-62203-hrtb-ice.rs:42:16: 42:19}>` to implement `for<'r> T0<'r, (&'r u8,)>` note: required for `L<{closure@$DIR/issue-62203-hrtb-ice.rs:40:16: 40:19}>` to implement `for<'r> T0<'r, (&'r u8,)>`
--> $DIR/issue-62203-hrtb-ice.rs:17:16 --> $DIR/issue-62203-hrtb-ice.rs:17:16
| |
LL | impl<'a, A, T> T0<'a, A> for L<T> LL | impl<'a, A, T> T0<'a, A> for L<T>

13
tests/ui/never_type/fallback-closure-wrap.fallback.stderr
View file

@ -1,16 +1,15 @@
error[E0271]: expected `{closure@fallback-closure-wrap.rs:18:40}` to be a closure that returns `()`, but it returns `!` error[E0271]: expected `{closure@fallback-closure-wrap.rs:18:40}` to be a closure that returns `()`, but it returns `!`
--> $DIR/fallback-closure-wrap.rs:18:31 --> $DIR/fallback-closure-wrap.rs:19:9
| |
LL | let error = Closure::wrap(Box::new(move || { LL | let error = Closure::wrap(Box::new(move || {
| _______________________________^ | -------
LL | | LL | panic!("Can't connect to server.");
LL | | panic!("Can't connect to server."); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `()`, found `!`
LL | | }) as Box<dyn FnMut()>);
| |______^ expected `()`, found `!`
| |
= note: expected unit type `()` = note: expected unit type `()`
found type `!` found type `!`
= note: required for the cast from `Box<{closure@$DIR/fallback-closure-wrap.rs:18:40: 18:47}>` to `Box<dyn FnMut()>` = note: required for the cast from `Box<{closure@$DIR/fallback-closure-wrap.rs:18:40: 18:47}>` to `Box<dyn FnMut()>`
= note: this error originates in the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
error: aborting due to 1 previous error error: aborting due to 1 previous error

2
tests/ui/never_type/fallback-closure-wrap.rs
View file

@ -16,8 +16,8 @@ use std::marker::PhantomData;
fn main() { fn main() {
let error = Closure::wrap(Box::new(move || { let error = Closure::wrap(Box::new(move || {
//[fallback]~^ to be a closure that returns `()`, but it returns `!`
panic!("Can't connect to server."); panic!("Can't connect to server.");
//[fallback]~^ to be a closure that returns `()`, but it returns `!`
}) as Box<dyn FnMut()>); }) as Box<dyn FnMut()>);
} }