Skip to content

Commit 1d5fc77

Browse files
borsbors
committed
Auto merge of rust-lang#138438 - compiler-errors:delay-coerce-err, r=<try>
[experiment] Delay coercion error rather than emitting error in `coerce_unsized` cc rust-lang#136127 (comment) r? `@ghost`
2 parents cb50d4d + 6551008 commit 1d5fc77

38 files changed

+322
-238
lines changed

‎compiler/rustc_hir_typeck/src/cast.rs

Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -353,6 +353,14 @@ impl<'a, 'tcx> CastCheck<'tcx> {
353353
PointerKind::Thin,
354354
)
355355
| (PointerKind::Length, PointerKind::Length) => {
356+
if let Some(_guar) = fcx.emit_specialized_coerce_unsize_error(
357+
self.expr.span,
358+
self.expr_ty,
359+
self.cast_ty,
360+
) {
361+
return;
362+
}
363+
356364
span_bug!(self.span, "unexpected cast error: {e:?}")
357365
}
358366
}
@@ -401,6 +409,14 @@ impl<'a, 'tcx> CastCheck<'tcx> {
401409
err.emit();
402410
}
403411
CastError::NonScalar => {
412+
if let Some(_guar) = fcx.emit_specialized_coerce_unsize_error(
413+
self.expr.span,
414+
self.expr_ty,
415+
self.cast_ty,
416+
) {
417+
return;
418+
}
419+
404420
let mut err = type_error_struct!(
405421
fcx.dcx(),
406422
self.span,
@@ -550,6 +566,14 @@ impl<'a, 'tcx> CastCheck<'tcx> {
550566
err.emit();
551567
}
552568
CastError::SizedUnsizedCast => {
569+
if let Some(_guar) = fcx.emit_specialized_coerce_unsize_error(
570+
self.expr.span,
571+
self.expr_ty,
572+
self.cast_ty,
573+
) {
574+
return;
575+
}
576+
553577
let cast_ty = fcx.resolve_vars_if_possible(self.cast_ty);
554578
let expr_ty = fcx.resolve_vars_if_possible(self.expr_ty);
555579
fcx.dcx().emit_err(errors::CastThinPointerToWidePointer {

‎compiler/rustc_hir_typeck/src/coercion.rs

Lines changed: 60 additions & 62 deletions
Original file line numberDiff line numberDiff line change
@@ -48,20 +48,20 @@ use rustc_infer::infer::relate::RelateResult;
4848
use rustc_infer::infer::{Coercion, DefineOpaqueTypes, InferOk, InferResult};
4949
use rustc_infer::traits::{
5050
IfExpressionCause, MatchExpressionArmCause, Obligation, PredicateObligation,
51-
PredicateObligations,
51+
PredicateObligations, SelectionError,
5252
};
5353
use rustc_middle::span_bug;
5454
use rustc_middle::ty::adjustment::{
5555
Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability, PointerCoercion,
5656
};
5757
use rustc_middle::ty::error::TypeError;
5858
use rustc_middle::ty::visit::TypeVisitableExt;
59-
use rustc_middle::ty::{self, AliasTy, GenericArgsRef, Ty, TyCtxt};
60-
use rustc_span::{BytePos, DUMMY_SP, DesugaringKind, Span};
59+
use rustc_middle::ty::{self, GenericArgsRef, Ty, TyCtxt};
60+
use rustc_span::{BytePos, DUMMY_SP, DesugaringKind, ErrorGuaranteed, Span};
6161
use rustc_trait_selection::infer::InferCtxtExt as _;
6262
use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt;
6363
use rustc_trait_selection::traits::{
64-
self, NormalizeExt, ObligationCause, ObligationCauseCode, ObligationCtxt,
64+
self, FulfillmentErrorCode, NormalizeExt, ObligationCause, ObligationCauseCode, ObligationCtxt,
6565
};
6666
use smallvec::{SmallVec, smallvec};
6767
use tracing::{debug, instrument};
@@ -600,55 +600,8 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
600600
ty::TraitRef::new(self.tcx, coerce_unsized_did, [coerce_source, coerce_target]),
601601
);
602602

603-
// If the root `Source: CoerceUnsized<Target>` obligation can't possibly hold,
604-
// we don't have to assume that this is unsizing coercion (it will always lead to an error)
605-
//
606-
// However, we don't want to bail early all the time, since the unholdable obligations
607-
// may be interesting for diagnostics (such as trying to coerce `&T` to `&dyn Id<This = U>`),
608-
// so we only bail if there (likely) is another way to convert the types.
609603
if !self.infcx.predicate_may_hold(&root_obligation) {
610-
if let Some(dyn_metadata_adt_def_id) = self.tcx.lang_items().get(LangItem::DynMetadata)
611-
&& let Some(metadata_type_def_id) = self.tcx.lang_items().get(LangItem::Metadata)
612-
{
613-
self.probe(|_| {
614-
let ocx = ObligationCtxt::new(&self.infcx);
615-
616-
// returns `true` if `<ty as Pointee>::Metadata` is `DynMetadata<_>`
617-
let has_dyn_trait_metadata = |ty| {
618-
let metadata_ty: Result<_, _> = ocx.structurally_normalize_ty(
619-
&ObligationCause::dummy(),
620-
self.fcx.param_env,
621-
Ty::new_alias(
622-
self.tcx,
623-
ty::AliasTyKind::Projection,
624-
AliasTy::new(self.tcx, metadata_type_def_id, [ty]),
625-
),
626-
);
627-
628-
metadata_ty.is_ok_and(|metadata_ty| {
629-
metadata_ty
630-
.ty_adt_def()
631-
.is_some_and(|d| d.did() == dyn_metadata_adt_def_id)
632-
})
633-
};
634-
635-
// If both types are raw pointers to a (wrapper over a) trait object,
636-
// this might be a cast like `*const W<dyn Trait> -> *const dyn Trait`.
637-
// So it's better to bail and try that. (even if the cast is not possible, for
638-
// example due to vtables not matching, cast diagnostic will likely still be better)
639-
//
640-
// N.B. use `target`, not `coerce_target` (the latter is a var)
641-
if let &ty::RawPtr(source_pointee, _) = coerce_source.kind()
642-
&& let &ty::RawPtr(target_pointee, _) = target.kind()
643-
&& has_dyn_trait_metadata(source_pointee)
644-
&& has_dyn_trait_metadata(target_pointee)
645-
{
646-
return Err(TypeError::Mismatch);
647-
}
648-
649-
Ok(())
650-
})?;
651-
}
604+
return Err(TypeError::Mismatch);
652605
}
653606

654607
// Use a FIFO queue for this custom fulfillment procedure.
@@ -725,17 +678,10 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
725678
return Err(TypeError::Mismatch);
726679
}
727680

728-
// Dyn-compatibility violations or miscellaneous.
681+
// Should have been filtered out by the `predicate_may_hold` check.
729682
Err(err) => {
730-
let guar = self.err_ctxt().report_selection_error(
731-
obligation.clone(),
732-
&obligation,
733-
&err,
734-
);
735-
self.fcx.set_tainted_by_errors(guar);
736-
// Treat this like an obligation and follow through
737-
// with the unsizing - the lack of a coercion should
738-
// be silent, as it causes a type mismatch later.
683+
debug!("coerce_unsized: early return - selection error: {err:?}");
684+
return Err(TypeError::Mismatch);
739685
}
740686

741687
Ok(Some(impl_source)) => queue.extend(impl_source.nested_obligations()),
@@ -1120,6 +1066,50 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
11201066
})
11211067
}
11221068

1069+
pub(crate) fn emit_specialized_coerce_unsize_error(
1070+
&self,
1071+
span: Span,
1072+
source: Ty<'tcx>,
1073+
target: Ty<'tcx>,
1074+
) -> Option<ErrorGuaranteed> {
1075+
let ocx = ObligationCtxt::new_with_diagnostics(self);
1076+
let coerce_unsized_def_id = self.tcx.require_lang_item(LangItem::CoerceUnsized, Some(span));
1077+
let unsize_def_id = self.tcx.require_lang_item(LangItem::Unsize, Some(span));
1078+
ocx.register_obligation(Obligation::new(
1079+
self.tcx,
1080+
self.cause(span, ObligationCauseCode::Coercion { source, target }),
1081+
self.param_env,
1082+
ty::TraitRef::new(self.tcx, coerce_unsized_def_id, [source, target]),
1083+
));
1084+
1085+
let mut errors = ocx.select_where_possible();
1086+
// Retain the errors that don't mention, but also as a HACK we will adjust their
1087+
// root obligation, too. This is a nasty hack to preserve diagnostic parity that
1088+
// should probably be fixed by emitting better errors for failed `CoerceUnsized`.
1089+
errors.retain_mut(|err| {
1090+
if matches!(
1091+
err.code,
1092+
FulfillmentErrorCode::Select(SelectionError::TraitDynIncompatible(_)),
1093+
) || err.obligation.predicate.as_trait_clause().is_none_or(|trait_clause| {
1094+
trait_clause.def_id() != coerce_unsized_def_id
1095+
&& trait_clause.def_id() != unsize_def_id
1096+
}) {
1097+
err.root_obligation = err.obligation.clone();
1098+
true
1099+
} else {
1100+
false
1101+
}
1102+
});
1103+
1104+
if errors.is_empty() {
1105+
None
1106+
} else {
1107+
let guar = self.err_ctxt().report_fulfillment_errors(errors);
1108+
self.set_tainted_by_errors(guar);
1109+
Some(guar)
1110+
}
1111+
}
1112+
11231113
/// Probe whether `expr_ty` can be coerced to `target_ty`. This has no side-effects,
11241114
/// and may return false positives if types are not yet fully constrained by inference.
11251115
///
@@ -1666,6 +1656,14 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> {
16661656
}
16671657
}
16681658
Err(coercion_error) => {
1659+
if let Some(_guar) = fcx.emit_specialized_coerce_unsize_error(
1660+
cause.span,
1661+
expression_ty,
1662+
self.merged_ty(),
1663+
) {
1664+
return;
1665+
}
1666+
16691667
// Mark that we've failed to coerce the types here to suppress
16701668
// any superfluous errors we might encounter while trying to
16711669
// emit or provide suggestions on how to fix the initial error.

‎compiler/rustc_hir_typeck/src/demand.rs

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -268,6 +268,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
268268
Err(e) => e,
269269
};
270270

271+
if let Some(guar) =
272+
self.emit_specialized_coerce_unsize_error(expr.span, checked_ty, expected)
273+
{
274+
return Ok(Ty::new_error(self.tcx, guar));
275+
}
276+
271277
self.adjust_expr_for_assert_eq_macro(&mut expr, &mut expected_ty_expr);
272278

273279
self.set_tainted_by_errors(self.dcx().span_delayed_bug(

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

Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -972,6 +972,30 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
972972
true
973973
});
974974

975+
// We need to handle type mismatches due to unsizing failures specially.
976+
errors.retain(|err| {
977+
if let Error::Invalid(
978+
provided_idx,
979+
expected_idx,
980+
Compatibility::Incompatible(Some(_)),
981+
) = *err
982+
{
983+
let (_, expected_ty) = formal_and_expected_inputs[expected_idx];
984+
let (provided_ty, provided_arg_span) = provided_arg_tys[provided_idx];
985+
986+
if let Some(guar) = self.emit_specialized_coerce_unsize_error(
987+
provided_arg_span,
988+
provided_ty,
989+
expected_ty,
990+
) {
991+
reported = Some(guar);
992+
return false;
993+
}
994+
}
995+
996+
true
997+
});
998+
975999
// We're done if we found errors, but we already emitted them.
9761000
if let Some(reported) = reported
9771001
&& errors.is_empty()

‎compiler/rustc_trait_selection/src/traits/select/confirmation.rs

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1223,6 +1223,15 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
12231223
&obligation.cause,
12241224
);
12251225

1226+
let pointer_like_goal = normalize_with_depth_to(
1227+
self,
1228+
obligation.param_env,
1229+
obligation.cause.clone(),
1230+
obligation.recursion_depth,
1231+
pointer_like_goal,
1232+
&mut nested,
1233+
);
1234+
12261235
nested.push(predicate_to_obligation(pointer_like_goal.upcast(tcx)));
12271236
}
12281237
}

‎tests/ui/async-await/async-block-control-flow-static-semantics.stderr

Lines changed: 11 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -14,6 +14,14 @@ LL | async {
1414
LL | break 0u8;
1515
| ^^^^^^^^^ cannot `break` inside `async` block
1616

17+
error[E0271]: expected `{async block@$DIR/async-block-control-flow-static-semantics.rs:23:17: 23:22}` to be a future that resolves to `()`, but it resolves to `u8`
18+
--> $DIR/async-block-control-flow-static-semantics.rs:26:39
19+
|
20+
LL | let _: &dyn Future<Output = ()> = &block;
21+
| ^^^^^^ expected `()`, found `u8`
22+
|
23+
= note: required for the cast from `&{async block@$DIR/async-block-control-flow-static-semantics.rs:23:17: 23:22}` to `&dyn Future<Output = ()>`
24+
1725
error[E0308]: mismatched types
1826
--> $DIR/async-block-control-flow-static-semantics.rs:21:58
1927
|
@@ -26,13 +34,13 @@ LL | | return 0u8;
2634
LL | | }
2735
| |_^ expected `u8`, found `()`
2836

29-
error[E0271]: expected `{async block@$DIR/async-block-control-flow-static-semantics.rs:23:17: 23:22}` to be a future that resolves to `()`, but it resolves to `u8`
30-
--> $DIR/async-block-control-flow-static-semantics.rs:26:39
37+
error[E0271]: expected `{async block@$DIR/async-block-control-flow-static-semantics.rs:14:17: 14:22}` to be a future that resolves to `()`, but it resolves to `u8`
38+
--> $DIR/async-block-control-flow-static-semantics.rs:17:39
3139
|
3240
LL | let _: &dyn Future<Output = ()> = &block;
3341
| ^^^^^^ expected `()`, found `u8`
3442
|
35-
= note: required for the cast from `&{async block@$DIR/async-block-control-flow-static-semantics.rs:23:17: 23:22}` to `&dyn Future<Output = ()>`
43+
= note: required for the cast from `&{async block@$DIR/async-block-control-flow-static-semantics.rs:14:17: 14:22}` to `&dyn Future<Output = ()>`
3644

3745
error[E0308]: mismatched types
3846
--> $DIR/async-block-control-flow-static-semantics.rs:12:43
@@ -42,14 +50,6 @@ LL | fn return_targets_async_block_not_fn() -> u8 {
4250
| |
4351
| implicitly returns `()` as its body has no tail or `return` expression
4452

45-
error[E0271]: expected `{async block@$DIR/async-block-control-flow-static-semantics.rs:14:17: 14:22}` to be a future that resolves to `()`, but it resolves to `u8`
46-
--> $DIR/async-block-control-flow-static-semantics.rs:17:39
47-
|
48-
LL | let _: &dyn Future<Output = ()> = &block;
49-
| ^^^^^^ expected `()`, found `u8`
50-
|
51-
= note: required for the cast from `&{async block@$DIR/async-block-control-flow-static-semantics.rs:14:17: 14:22}` to `&dyn Future<Output = ()>`
52-
5353
error[E0308]: mismatched types
5454
--> $DIR/async-block-control-flow-static-semantics.rs:49:44
5555
|

‎tests/ui/cross/cross-borrow-trait.stderr

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -8,6 +8,10 @@ LL | let _y: &dyn Trait = x;
88
|
99
= note: expected reference `&dyn Trait`
1010
found struct `Box<dyn Trait>`
11+
help: consider borrowing here
12+
|
13+
LL | let _y: &dyn Trait = &x;
14+
| +
1115

1216
error: aborting due to 1 previous error
1317

‎tests/ui/custom_test_frameworks/mismatch.rs

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,5 @@
1+
//~ ERROR mismatched types
2+
13
//@ aux-build:example_runner.rs
24
//@ compile-flags:--test
35
#![feature(custom_test_frameworks)]

‎tests/ui/custom_test_frameworks/mismatch.stderr

Lines changed: 14 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
error[E0277]: the trait bound `TestDescAndFn: Testable` is not satisfied
2-
--> $DIR/mismatch.rs:9:1
2+
--> $DIR/mismatch.rs:11:1
33
|
44
LL | #[test]
55
| ------- in this procedural macro expansion
@@ -9,6 +9,17 @@ LL | fn wrong_kind(){}
99
= note: required for the cast from `&TestDescAndFn` to `&dyn Testable`
1010
= note: this error originates in the attribute macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)
1111

12-
error: aborting due to 1 previous error
12+
error[E0308]: mismatched types
13+
|
14+
= note: expected reference `&[&dyn Testable]`
15+
found reference `&[!; 1]`
16+
note: function defined here
17+
--> $DIR/auxiliary/example_runner.rs:6:8
18+
|
19+
LL | pub fn runner(tests: &[&dyn Testable]) {
20+
| ^^^^^^
21+
22+
error: aborting due to 2 previous errors
1323

14-
For more information about this error, try `rustc --explain E0277`.
24+
Some errors have detailed explanations: E0277, E0308.
25+
For more information about an error, try `rustc --explain E0277`.

‎tests/ui/dst/dst-object-from-unsized-type.rs

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -17,6 +17,7 @@ fn test2<T: ?Sized + Foo>(t: &T) {
1717
fn test3() {
1818
let _: &[&dyn Foo] = &["hi"];
1919
//~^ ERROR the size for values of type
20+
//~| ERROR mismatched types
2021
}
2122

2223
fn test4(x: &[u8]) {

0 commit comments

Comments
 (0)