Skip to content

Commit f889883

Browse files
compiler-errorscompiler-errors
committed
Do not deduplicate list of associated types provided by dyn principal
1 parent 124cc92 commit f889883

18 files changed

+255
-117
lines changed

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

Lines changed: 99 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
use rustc_data_structures::fx::{FxHashSet, FxIndexSet};
1+
use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
22
use rustc_errors::codes::*;
33
use rustc_errors::struct_span_code_err;
44
use rustc_hir as hir;
@@ -59,9 +59,9 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
5959
}
6060
}
6161

62-
let (trait_bounds, mut projection_bounds) =
62+
let (elaborated_trait_bounds, elaborated_projection_bounds) =
6363
traits::expand_trait_aliases(tcx, user_written_bounds.clauses());
64-
let (regular_traits, mut auto_traits): (Vec<_>, Vec<_>) = trait_bounds
64+
let (regular_traits, mut auto_traits): (Vec<_>, Vec<_>) = elaborated_trait_bounds
6565
.into_iter()
6666
.partition(|(trait_ref, _)| !tcx.trait_is_auto(trait_ref.def_id()));
6767

@@ -102,37 +102,89 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
102102
}
103103
}
104104

105+
// Map the projection bounds onto a key that makes it easy to remove redundant
106+
// bounds that are constrained by supertraits of the principal def id.
107+
//
108+
// Also make sure we detect conflicting bounds from expanding a trait alias and
109+
// also specifying it manually, like:
110+
// ```
111+
// type Alias = Trait<Assoc = i32>;
112+
// let _: &dyn Alias<Assoc = u32> = /* ... */;
113+
// ```
114+
let mut projection_bounds = FxIndexMap::default();
115+
for (proj, proj_span) in elaborated_projection_bounds {
116+
let key = (
117+
proj.skip_binder().projection_term.def_id,
118+
tcx.anonymize_bound_vars(
119+
proj.map_bound(|proj| proj.projection_term.trait_ref(tcx)),
120+
),
121+
);
122+
if let Some((old_proj, old_proj_span)) =
123+
projection_bounds.insert(key, (proj, proj_span))
124+
&& tcx.anonymize_bound_vars(proj) != tcx.anonymize_bound_vars(old_proj)
125+
{
126+
let item = tcx.item_name(proj.item_def_id());
127+
self.dcx()
128+
.struct_span_err(
129+
span,
130+
format!(
131+
"conflicting associated type bounds for `{item}` when \
132+
expanding trait alias"
133+
),
134+
)
135+
.with_span_label(
136+
old_proj_span,
137+
format!("`{item}` is specified to be `{}` here", old_proj.term()),
138+
)
139+
.with_span_label(
140+
proj_span,
141+
format!("`{item}` is specified to be `{}` here", proj.term()),
142+
)
143+
.emit();
144+
}
145+
}
146+
105147
let principal_trait = regular_traits.into_iter().next();
106148

107-
let mut needed_associated_types = FxIndexSet::default();
108-
if let Some((principal_trait, spans)) = &principal_trait {
109-
let pred: ty::Predicate<'tcx> = (*principal_trait).upcast(tcx);
110-
for ClauseWithSupertraitSpan { pred, supertrait_span } in traits::elaborate(
149+
let mut needed_associated_types = vec![];
150+
if let Some((principal_trait, ref spans)) = principal_trait {
151+
let principal_trait = principal_trait.map_bound(|trait_pred| {
152+
assert_eq!(trait_pred.polarity, ty::PredicatePolarity::Positive);
153+
trait_pred.trait_ref
154+
});
155+
156+
for ClauseWithSupertraitSpan { clause, supertrait_span } in traits::elaborate(
111157
tcx,
112-
[ClauseWithSupertraitSpan::new(pred, *spans.last().unwrap())],
158+
[ClauseWithSupertraitSpan::new(
159+
ty::TraitRef::identity(tcx, principal_trait.def_id()).upcast(tcx),
160+
*spans.last().unwrap(),
161+
)],
113162
)
114163
.filter_only_self()
115164
{
116-
debug!("observing object predicate `{pred:?}`");
165+
let clause = clause.instantiate_supertrait(tcx, principal_trait);
166+
debug!("observing object predicate `{clause:?}`");
117167

118-
let bound_predicate = pred.kind();
168+
let bound_predicate = clause.kind();
119169
match bound_predicate.skip_binder() {
120-
ty::PredicateKind::Clause(ty::ClauseKind::Trait(pred)) => {
170+
ty::ClauseKind::Trait(pred) => {
121171
// FIXME(negative_bounds): Handle this correctly...
122172
let trait_ref =
123173
tcx.anonymize_bound_vars(bound_predicate.rebind(pred.trait_ref));
124174
needed_associated_types.extend(
125-
tcx.associated_items(trait_ref.def_id())
175+
tcx.associated_items(pred.trait_ref.def_id)
126176
.in_definition_order()
177+
// We only care about associated types.
127178
.filter(|item| item.kind == ty::AssocKind::Type)
179+
// No RPITITs -- even with `async_fn_in_dyn_trait`, they are implicit.
128180
.filter(|item| !item.is_impl_trait_in_trait())
129181
// If the associated type has a `where Self: Sized` bound,
130182
// we do not need to constrain the associated type.
131183
.filter(|item| !tcx.generics_require_sized_self(item.def_id))
132184
.map(|item| (item.def_id, trait_ref)),
133185
);
134186
}
135-
ty::PredicateKind::Clause(ty::ClauseKind::Projection(pred)) => {
187+
ty::ClauseKind::Projection(pred) => {
136188
let pred = bound_predicate.rebind(pred);
137189
// A `Self` within the original bound will be instantiated with a
138190
// `trait_object_dummy_self`, so check for that.
@@ -160,8 +212,15 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
160212
// `dyn MyTrait<MyOutput = X, Output = X>`, which is uglier but works. See
161213
// the discussion in #56288 for alternatives.
162214
if !references_self {
163-
// Include projections defined on supertraits.
164-
projection_bounds.push((pred, supertrait_span));
215+
let key = (
216+
pred.skip_binder().projection_term.def_id,
217+
tcx.anonymize_bound_vars(
218+
pred.map_bound(|proj| proj.projection_term.trait_ref(tcx)),
219+
),
220+
);
221+
if !projection_bounds.contains_key(&key) {
222+
projection_bounds.insert(key, (pred, supertrait_span));
223+
}
165224
}
166225

167226
self.check_elaborated_projection_mentions_input_lifetimes(
@@ -181,12 +240,8 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
181240
// types that we expect to be provided by the user, so the following loop
182241
// removes all the associated types that have a corresponding `Projection`
183242
// clause, either from expanding trait aliases or written by the user.
184-
for &(projection_bound, span) in &projection_bounds {
243+
for &(projection_bound, span) in projection_bounds.values() {
185244
let def_id = projection_bound.item_def_id();
186-
let trait_ref = tcx.anonymize_bound_vars(
187-
projection_bound.map_bound(|p| p.projection_term.trait_ref(tcx)),
188-
);
189-
needed_associated_types.swap_remove(&(def_id, trait_ref));
190245
if tcx.generics_require_sized_self(def_id) {
191246
tcx.emit_node_span_lint(
192247
UNUSED_ASSOCIATED_TYPE_BOUNDS,
@@ -197,9 +252,22 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
197252
}
198253
}
199254

255+
let mut missing_assoc_types = FxIndexSet::default();
256+
let projection_bounds: Vec<_> = needed_associated_types
257+
.into_iter()
258+
.filter_map(|key| {
259+
if let Some(assoc) = projection_bounds.get(&key) {
260+
Some(*assoc)
261+
} else {
262+
missing_assoc_types.insert(key);
263+
None
264+
}
265+
})
266+
.collect();
267+
200268
if let Err(guar) = self.check_for_required_assoc_tys(
201269
principal_trait.as_ref().map_or(smallvec![], |(_, spans)| spans.clone()),
202-
needed_associated_types,
270+
missing_assoc_types,
203271
potential_assoc_types,
204272
hir_bounds,
205273
) {
@@ -265,7 +333,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
265333
})
266334
});
267335

268-
let existential_projections = projection_bounds.iter().map(|(bound, _)| {
336+
let existential_projections = projection_bounds.into_iter().map(|(bound, _)| {
269337
bound.map_bound(|mut b| {
270338
assert_eq!(b.projection_term.self_ty(), dummy_self);
271339

@@ -290,12 +358,16 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
290358
})
291359
});
292360

293-
let auto_trait_predicates = auto_traits.into_iter().map(|(trait_pred, _)| {
294-
assert_eq!(trait_pred.polarity(), ty::PredicatePolarity::Positive);
295-
assert_eq!(trait_pred.self_ty().skip_binder(), dummy_self);
361+
let mut auto_trait_predicates: Vec<_> = auto_traits
362+
.into_iter()
363+
.map(|(trait_pred, _)| {
364+
assert_eq!(trait_pred.polarity(), ty::PredicatePolarity::Positive);
365+
assert_eq!(trait_pred.self_ty().skip_binder(), dummy_self);
296366

297-
ty::Binder::dummy(ty::ExistentialPredicate::AutoTrait(trait_pred.def_id()))
298-
});
367+
ty::Binder::dummy(ty::ExistentialPredicate::AutoTrait(trait_pred.def_id()))
368+
})
369+
.collect();
370+
auto_trait_predicates.dedup();
299371

300372
// N.b. principal, projections, auto traits
301373
// FIXME: This is actually wrong with multiple principals in regards to symbol mangling
@@ -305,7 +377,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
305377
.chain(auto_trait_predicates)
306378
.collect::<SmallVec<[_; 8]>>();
307379
v.sort_by(|a, b| a.skip_binder().stable_cmp(tcx, &b.skip_binder()));
308-
v.dedup();
309380
let existential_predicates = tcx.mk_poly_existential_predicates(&v);
310381

311382
// Use explicitly-specified region bound, unless the bound is missing.

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

Lines changed: 4 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -79,20 +79,11 @@ impl<'tcx> Relate<TyCtxt<'tcx>> for &'tcx ty::List<ty::PolyExistentialPredicate<
7979
b: Self,
8080
) -> RelateResult<'tcx, Self> {
8181
let tcx = relation.cx();
82-
83-
// FIXME: this is wasteful, but want to do a perf run to see how slow it is.
84-
// We need to perform this deduplication as we sometimes generate duplicate projections
85-
// in `a`.
86-
let mut a_v: Vec<_> = a.into_iter().collect();
87-
let mut b_v: Vec<_> = b.into_iter().collect();
88-
a_v.dedup();
89-
b_v.dedup();
90-
if a_v.len() != b_v.len() {
82+
if a.len() != b.len() {
9183
return Err(TypeError::ExistentialMismatch(ExpectedFound::new(a, b)));
9284
}
93-
94-
let v = iter::zip(a_v, b_v).map(|(ep_a, ep_b)| {
95-
match (ep_a.skip_binder(), ep_b.skip_binder()) {
85+
let v =
86+
iter::zip(a, b).map(|(ep_a, ep_b)| match (ep_a.skip_binder(), ep_b.skip_binder()) {
9687
(ty::ExistentialPredicate::Trait(a), ty::ExistentialPredicate::Trait(b)) => {
9788
Ok(ep_a.rebind(ty::ExistentialPredicate::Trait(
9889
relation.relate(ep_a.rebind(a), ep_b.rebind(b))?.skip_binder(),
@@ -109,8 +100,7 @@ impl<'tcx> Relate<TyCtxt<'tcx>> for &'tcx ty::List<ty::PolyExistentialPredicate<
109100
ty::ExistentialPredicate::AutoTrait(b),
110101
) if a == b => Ok(ep_a.rebind(ty::ExistentialPredicate::AutoTrait(a))),
111102
_ => Err(TypeError::ExistentialMismatch(ExpectedFound::new(a, b))),
112-
}
113-
});
103+
});
114104
tcx.mk_poly_existential_predicates_from_iter(v)
115105
}
116106
}

‎compiler/rustc_type_ir/src/elaborate.rs

Lines changed: 6 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -44,25 +44,22 @@ pub trait Elaboratable<I: Interner> {
4444
}
4545

4646
pub struct ClauseWithSupertraitSpan<I: Interner> {
47-
pub pred: I::Predicate,
47+
pub clause: I::Clause,
4848
// Span of the supertrait predicatae that lead to this clause.
4949
pub supertrait_span: I::Span,
5050
}
5151
impl<I: Interner> ClauseWithSupertraitSpan<I> {
52-
pub fn new(pred: I::Predicate, span: I::Span) -> Self {
53-
ClauseWithSupertraitSpan { pred, supertrait_span: span }
52+
pub fn new(clause: I::Clause, span: I::Span) -> Self {
53+
ClauseWithSupertraitSpan { clause, supertrait_span: span }
5454
}
5555
}
5656
impl<I: Interner> Elaboratable<I> for ClauseWithSupertraitSpan<I> {
5757
fn predicate(&self) -> <I as Interner>::Predicate {
58-
self.pred
58+
self.clause.as_predicate()
5959
}
6060

6161
fn child(&self, clause: <I as Interner>::Clause) -> Self {
62-
ClauseWithSupertraitSpan {
63-
pred: clause.as_predicate(),
64-
supertrait_span: self.supertrait_span,
65-
}
62+
ClauseWithSupertraitSpan { clause, supertrait_span: self.supertrait_span }
6663
}
6764

6865
fn child_with_derived_cause(
@@ -72,7 +69,7 @@ impl<I: Interner> Elaboratable<I> for ClauseWithSupertraitSpan<I> {
7269
_parent_trait_pred: crate::Binder<I, crate::TraitPredicate<I>>,
7370
_index: usize,
7471
) -> Self {
75-
ClauseWithSupertraitSpan { pred: clause.as_predicate(), supertrait_span }
72+
ClauseWithSupertraitSpan { clause, supertrait_span }
7673
}
7774
}
7875

‎tests/crashes/125957.rs

Lines changed: 0 additions & 20 deletions
This file was deleted.

‎tests/crashes/132330.rs

Lines changed: 0 additions & 28 deletions
This file was deleted.

‎tests/ui/associated-types/associated-types-overridden-binding-2.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -4,5 +4,5 @@ trait I32Iterator = Iterator<Item = i32>;
44

55
fn main() {
66
let _: &dyn I32Iterator<Item = u32> = &vec![42].into_iter();
7-
//~^ ERROR expected `IntoIter<u32>` to be an iterator that yields `i32`, but it yields `u32`
7+
//~^ ERROR conflicting associated type bounds
88
}

‎tests/ui/associated-types/associated-types-overridden-binding-2.stderr

Lines changed: 8 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,13 @@
1-
error[E0271]: expected `IntoIter<u32>` to be an iterator that yields `i32`, but it yields `u32`
2-
--> $DIR/associated-types-overridden-binding-2.rs:6:43
1+
error: conflicting associated type bounds for `Item` when expanding trait alias
2+
--> $DIR/associated-types-overridden-binding-2.rs:6:13
33
|
4+
LL | trait I32Iterator = Iterator<Item = i32>;
5+
| ---------- `Item` is specified to be `i32` here
6+
...
47
LL | let _: &dyn I32Iterator<Item = u32> = &vec![42].into_iter();
5-
| ^^^^^^^^^^^^^^^^^^^^^ expected `i32`, found `u32`
6-
|
7-
= note: required for the cast from `&std::vec::IntoIter<u32>` to `&dyn Iterator<Item = u32, Item = i32>`
8+
| ^^^^^^^^^^^^^^^^----------^
9+
| |
10+
| `Item` is specified to be `u32` here
811

912
error: aborting due to 1 previous error
1013

11-
For more information about this error, try `rustc --explain E0271`.

‎tests/ui/associated-types/associated-types-overridden-binding.rs

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -8,4 +8,5 @@ trait U32Iterator = I32Iterator<Item = u32>; //~ ERROR type annotations needed
88

99
fn main() {
1010
let _: &dyn I32Iterator<Item = u32>;
11+
//~^ ERROR conflicting associated type bounds
1112
}

‎tests/ui/associated-types/associated-types-overridden-binding.stderr

Lines changed: 12 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -22,6 +22,17 @@ note: required by a bound in `I32Iterator`
2222
LL | trait I32Iterator = Iterator<Item = i32>;
2323
| ^^^^^^^^^^ required by this bound in `I32Iterator`
2424

25-
error: aborting due to 2 previous errors
25+
error: conflicting associated type bounds for `Item` when expanding trait alias
26+
--> $DIR/associated-types-overridden-binding.rs:10:13
27+
|
28+
LL | trait I32Iterator = Iterator<Item = i32>;
29+
| ---------- `Item` is specified to be `i32` here
30+
...
31+
LL | let _: &dyn I32Iterator<Item = u32>;
32+
| ^^^^^^^^^^^^^^^^----------^
33+
| |
34+
| `Item` is specified to be `u32` here
35+
36+
error: aborting due to 3 previous errors
2637

2738
For more information about this error, try `rustc --explain E0284`.

0 commit comments

Comments
 (0)