Skip to content

Commit f827120

Browse files
borsbors
committed
Auto merge of #130367 - compiler-errors:super-unconstrained, r=<try>
Check elaborated projections from dyn don't mention unconstrained late bound lifetimes Check that the projections that are *not* explicitly written but which we deduce from elaborating the principal of a `dyn` *also* do not reference unconstrained late-bound lifetimes, just like the ones that the user writes by hand. Fixes #130347
2 parents 5fe0e40 + f16d211 commit f827120

File tree

8 files changed

+149
-18
lines changed

8 files changed

+149
-18
lines changed

‎compiler/rustc_hir_analysis/src/hir_ty_lowering/object_safety.rs

+64-4
Original file line numberDiff line numberDiff line change
@@ -13,6 +13,7 @@ use rustc_middle::ty::{
1313
use rustc_span::{ErrorGuaranteed, Span};
1414
use rustc_trait_selection::error_reporting::traits::report_object_safety_error;
1515
use rustc_trait_selection::traits::{self, hir_ty_lowering_object_safety_violations};
16+
use rustc_type_ir::elaborate::ClauseWithSupertraitSpan;
1617
use smallvec::{smallvec, SmallVec};
1718
use tracing::{debug, instrument};
1819

@@ -124,16 +125,19 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
124125
.into_iter()
125126
.filter(|(trait_ref, _)| !tcx.trait_is_auto(trait_ref.def_id()));
126127

127-
for (base_trait_ref, span) in regular_traits_refs_spans {
128+
for (base_trait_ref, original_span) in regular_traits_refs_spans {
128129
let base_pred: ty::Predicate<'tcx> = base_trait_ref.upcast(tcx);
129-
for pred in traits::elaborate(tcx, [base_pred]).filter_only_self() {
130+
for ClauseWithSupertraitSpan { pred, original_span, supertrait_span } in
131+
traits::elaborate(tcx, [ClauseWithSupertraitSpan::new(base_pred, original_span)])
132+
.filter_only_self()
133+
{
130134
debug!("observing object predicate `{pred:?}`");
131135

132136
let bound_predicate = pred.kind();
133137
match bound_predicate.skip_binder() {
134138
ty::PredicateKind::Clause(ty::ClauseKind::Trait(pred)) => {
135139
let pred = bound_predicate.rebind(pred);
136-
associated_types.entry(span).or_default().extend(
140+
associated_types.entry(original_span).or_default().extend(
137141
tcx.associated_items(pred.def_id())
138142
.in_definition_order()
139143
.filter(|item| item.kind == ty::AssocKind::Type)
@@ -172,8 +176,14 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
172176
// the discussion in #56288 for alternatives.
173177
if !references_self {
174178
// Include projections defined on supertraits.
175-
projection_bounds.push((pred, span));
179+
projection_bounds.push((pred, original_span));
176180
}
181+
182+
self.check_elaborated_projection_mentions_input_lifetimes(
183+
pred,
184+
original_span,
185+
supertrait_span,
186+
);
177187
}
178188
_ => (),
179189
}
@@ -358,6 +368,56 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
358368

359369
Ty::new_dynamic(tcx, existential_predicates, region_bound, representation)
360370
}
371+
372+
/// Check that elaborating the principal of a trait ref doesn't lead to projections
373+
/// that are unconstrained. This can happen because an otherwise unconstrained
374+
/// *type variable* can be substituted with a type that has late-bound regions. See
375+
/// `elaborated-predicates-unconstrained-late-bound.rs` for a test.
376+
fn check_elaborated_projection_mentions_input_lifetimes(
377+
&self,
378+
pred: ty::PolyProjectionPredicate<'tcx>,
379+
span: Span,
380+
supertrait_span: Span,
381+
) {
382+
let tcx = self.tcx();
383+
384+
// Find any late-bound regions declared in `ty` that are not
385+
// declared in the trait-ref or assoc_item. These are not well-formed.
386+
//
387+
// Example:
388+
//
389+
// for<'a> <T as Iterator>::Item = &'a str // <-- 'a is bad
390+
// for<'a> <T as FnMut<(&'a u32,)>>::Output = &'a str // <-- 'a is ok
391+
let late_bound_in_projection_term =
392+
tcx.collect_constrained_late_bound_regions(pred.map_bound(|pred| pred.projection_term));
393+
let late_bound_in_term =
394+
tcx.collect_referenced_late_bound_regions(pred.map_bound(|pred| pred.term));
395+
debug!(?late_bound_in_projection_term);
396+
debug!(?late_bound_in_term);
397+
398+
// FIXME: point at the type params that don't have appropriate lifetimes:
399+
// struct S1<F: for<'a> Fn(&i32, &i32) -> &'a i32>(F);
400+
// ---- ---- ^^^^^^^
401+
// NOTE(associated_const_equality): This error should be impossible to trigger
402+
// with associated const equality constraints.
403+
self.validate_late_bound_regions(
404+
late_bound_in_projection_term,
405+
late_bound_in_term,
406+
|br_name| {
407+
let item_name = tcx.item_name(pred.projection_def_id());
408+
struct_span_code_err!(
409+
self.dcx(),
410+
span,
411+
E0582,
412+
"binding for associated type `{}` references {}, \
413+
which does not appear in the trait input types",
414+
item_name,
415+
br_name
416+
)
417+
.with_span_label(supertrait_span, "due to this supertrait")
418+
},
419+
);
420+
}
361421
}
362422

363423
fn replace_dummy_self_with_error<'tcx, T: TypeFoldable<TyCtxt<'tcx>>>(

‎compiler/rustc_middle/src/ty/predicate.rs

+4
Original file line numberDiff line numberDiff line change
@@ -179,6 +179,10 @@ pub struct Clause<'tcx>(
179179
);
180180

181181
impl<'tcx> rustc_type_ir::inherent::Clause<TyCtxt<'tcx>> for Clause<'tcx> {
182+
fn as_predicate(self) -> Predicate<'tcx> {
183+
self.as_predicate()
184+
}
185+
182186
fn instantiate_supertrait(self, tcx: TyCtxt<'tcx>, trait_ref: ty::PolyTraitRef<'tcx>) -> Self {
183187
self.instantiate_supertrait(tcx, trait_ref)
184188
}

‎compiler/rustc_type_ir/src/elaborate.rs

+40
Original file line numberDiff line numberDiff line change
@@ -43,6 +43,46 @@ pub trait Elaboratable<I: Interner> {
4343
) -> Self;
4444
}
4545

46+
pub struct ClauseWithSupertraitSpan<I: Interner> {
47+
pub pred: I::Predicate,
48+
// Span of the original elaborated predicate.
49+
pub original_span: I::Span,
50+
// Span of the supertrait predicatae that lead to this clause.
51+
pub supertrait_span: I::Span,
52+
}
53+
impl<I: Interner> ClauseWithSupertraitSpan<I> {
54+
pub fn new(pred: I::Predicate, span: I::Span) -> Self {
55+
ClauseWithSupertraitSpan { pred, original_span: span, supertrait_span: span }
56+
}
57+
}
58+
impl<I: Interner> Elaboratable<I> for ClauseWithSupertraitSpan<I> {
59+
fn predicate(&self) -> <I as Interner>::Predicate {
60+
self.pred
61+
}
62+
63+
fn child(&self, clause: <I as Interner>::Clause) -> Self {
64+
ClauseWithSupertraitSpan {
65+
pred: clause.as_predicate(),
66+
original_span: self.original_span,
67+
supertrait_span: self.supertrait_span,
68+
}
69+
}
70+
71+
fn child_with_derived_cause(
72+
&self,
73+
clause: <I as Interner>::Clause,
74+
supertrait_span: <I as Interner>::Span,
75+
_parent_trait_pred: crate::Binder<I, crate::TraitPredicate<I>>,
76+
_index: usize,
77+
) -> Self {
78+
ClauseWithSupertraitSpan {
79+
pred: clause.as_predicate(),
80+
original_span: self.original_span,
81+
supertrait_span: supertrait_span,
82+
}
83+
}
84+
}
85+
4686
pub fn elaborate<I: Interner, O: Elaboratable<I>>(
4787
cx: I,
4888
obligations: impl IntoIterator<Item = O>,

‎compiler/rustc_type_ir/src/inherent.rs

+2
Original file line numberDiff line numberDiff line change
@@ -460,6 +460,8 @@ pub trait Clause<I: Interner<Clause = Self>>:
460460
+ IntoKind<Kind = ty::Binder<I, ty::ClauseKind<I>>>
461461
+ Elaboratable<I>
462462
{
463+
fn as_predicate(self) -> I::Predicate;
464+
463465
fn as_trait_clause(self) -> Option<ty::Binder<I, ty::TraitPredicate<I>>> {
464466
self.kind()
465467
.map_bound(|clause| if let ty::ClauseKind::Trait(t) = clause { Some(t) } else { None })

‎tests/ui/traits/object/elaborated-predicates-unconstrained-late-bound.rs

+24
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
// Make sure that when elaborating the principal of a dyn trait for projection predicates
2+
// we don't end up in a situation where we have an unconstrained late-bound lifetime in
3+
// the output of a projection.
4+
5+
// Fix for <https://github.com/rust-lang/rust/issues/130347>.
6+
7+
trait A<T>: B<T = T> {}
8+
9+
trait B {
10+
type T;
11+
}
12+
13+
struct Erase<T: ?Sized + B>(T::T);
14+
15+
fn main() {
16+
let x = {
17+
let x = String::from("hello");
18+
19+
Erase::<dyn for<'a> A<&'a _>>(x.as_str())
20+
//~^ ERROR binding for associated type `T` references lifetime `'a`, which does not appear in the trait input types
21+
};
22+
23+
dbg!(x.0);
24+
}

‎tests/ui/traits/object/elaborated-predicates-unconstrained-late-bound.stderr

+12
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,12 @@
1+
error[E0582]: binding for associated type `T` references lifetime `'a`, which does not appear in the trait input types
2+
--> $DIR/elaborated-predicates-unconstrained-late-bound.rs:19:21
3+
|
4+
LL | trait A<T>: B<T = T> {}
5+
| ----- due to this supertrait
6+
...
7+
LL | Erase::<dyn for<'a> A<&'a _>>(x.as_str())
8+
| ^^^^^^^^^^^^^^^^
9+
10+
error: aborting due to 1 previous error
11+
12+
For more information about this error, try `rustc --explain E0582`.

‎tests/ui/traits/object/pretty.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,7 @@ trait SuperGeneric<'a> {
1313
}
1414
trait AnyGeneric<'a>: SuperGeneric<'a> {}
1515
trait FixedGeneric1<'a>: SuperGeneric<'a, Assoc2 = &'a u8> {}
16-
trait FixedGeneric2<'a>: Super<Assoc = &'a u8> {}
16+
// trait FixedGeneric2<'a>: Super<Assoc = &'a u8> {} // Unsound!
1717
trait FixedHrtb: for<'a> SuperGeneric<'a, Assoc2 = &'a u8> {}
1818
trait AnyDifferentBinders: for<'a> SuperGeneric<'a, Assoc2 = &'a u8> + Super {}
1919
trait FixedDifferentBinders: for<'a> SuperGeneric<'a, Assoc2 = &'a u8> + Super<Assoc = u8> {}
@@ -32,7 +32,7 @@ fn dyn_fixed_static(x: &dyn FixedStatic) { x } //~ERROR mismatched types
3232
fn dyn_super_generic(x: &dyn for<'a> SuperGeneric<'a, Assoc2 = &'a u8>) { x } //~ERROR mismatched types
3333
fn dyn_any_generic(x: &dyn for<'a> AnyGeneric<'a, Assoc2 = &'a u8>) { x } //~ERROR mismatched types
3434
fn dyn_fixed_generic1(x: &dyn for<'a> FixedGeneric1<'a>) { x } //~ERROR mismatched types
35-
fn dyn_fixed_generic2(x: &dyn for<'a> FixedGeneric2<'a>) { x } //~ERROR mismatched types
35+
// fn dyn_fixed_generic2(x: &dyn for<'a> FixedGeneric2<'a>) { x } // Unsound!
3636
fn dyn_fixed_generic_multi(x: &dyn for<'a> FixedGeneric1<'a, Assoc2 = &u8>) { x } //~ERROR mismatched types
3737
fn dyn_fixed_hrtb(x: &dyn FixedHrtb) { x } //~ERROR mismatched types
3838
fn dyn_any_different_binders(x: &dyn AnyDifferentBinders<Assoc = u8>) { x } //~ERROR mismatched types

‎tests/ui/traits/object/pretty.stderr

+1-12
Original file line numberDiff line numberDiff line change
@@ -106,17 +106,6 @@ LL | fn dyn_fixed_generic1(x: &dyn for<'a> FixedGeneric1<'a>) { x }
106106
= note: expected unit type `()`
107107
found reference `&dyn for<'a> FixedGeneric1<'a>`
108108

109-
error[E0308]: mismatched types
110-
--> $DIR/pretty.rs:35:60
111-
|
112-
LL | fn dyn_fixed_generic2(x: &dyn for<'a> FixedGeneric2<'a>) { x }
113-
| - ^ expected `()`, found `&dyn FixedGeneric2<'a>`
114-
| |
115-
| help: try adding a return type: `-> &dyn for<'a> FixedGeneric2<'a>`
116-
|
117-
= note: expected unit type `()`
118-
found reference `&dyn for<'a> FixedGeneric2<'a>`
119-
120109
error[E0308]: mismatched types
121110
--> $DIR/pretty.rs:36:79
122111
|
@@ -172,6 +161,6 @@ LL | fn dyn_has_gat(x: &dyn HasGat<u8, Assoc<bool> = ()>) { x }
172161
= note: expected unit type `()`
173162
found reference `&dyn HasGat<u8, Assoc<bool> = ()>`
174163

175-
error: aborting due to 15 previous errors; 1 warning emitted
164+
error: aborting due to 14 previous errors; 1 warning emitted
176165

177166
For more information about this error, try `rustc --explain E0308`.

0 commit comments

Comments
 (0)