Skip to content

Commit d3aecc1

Browse files
jackh726jackh726
committed
When obligation is a sized predicate, prefer projection or object candidates instead of param_env candidates
1 parent dde825d commit d3aecc1

File tree

13 files changed

+84
-34
lines changed

13 files changed

+84
-34
lines changed

‎compiler/rustc_infer/src/traits/util.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -152,7 +152,7 @@ impl Elaborator<'tcx> {
152152
obligation.cause.clone(),
153153
)
154154
});
155-
debug!("super_predicates: data={:?}", data);
155+
debug!(?data, ?obligations, "super_predicates");
156156

157157
// Only keep those bounds that we haven't already seen.
158158
// This is necessary to prevent infinite recursion in some

‎compiler/rustc_middle/src/ty/print/mod.rs

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -188,6 +188,11 @@ pub trait Printer<'tcx>: Sized {
188188
own_params.start = 1;
189189
}
190190

191+
// If we're in verbose mode, then print default-equal args too
192+
if self.tcx().sess.verbose() {
193+
return &substs[own_params];
194+
}
195+
191196
// Don't print args that are the defaults of their respective parameters.
192197
own_params.end -= generics
193198
.params

‎compiler/rustc_middle/src/ty/print/pretty.rs

Lines changed: 5 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1776,10 +1776,11 @@ impl<F: fmt::Write> Printer<'tcx> for FmtPrinter<'_, 'tcx, F> {
17761776
self = print_prefix(self)?;
17771777

17781778
// Don't print `'_` if there's no unerased regions.
1779-
let print_regions = args.iter().any(|arg| match arg.unpack() {
1780-
GenericArgKind::Lifetime(r) => *r != ty::ReErased,
1781-
_ => false,
1782-
});
1779+
let print_regions = self.tcx.sess.verbose()
1780+
|| args.iter().any(|arg| match arg.unpack() {
1781+
GenericArgKind::Lifetime(r) => *r != ty::ReErased,
1782+
_ => false,
1783+
});
17831784
let args = args.iter().cloned().filter(|arg| match arg.unpack() {
17841785
GenericArgKind::Lifetime(_) => print_regions,
17851786
_ => true,

‎compiler/rustc_trait_selection/src/traits/project.rs

Lines changed: 5 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1242,6 +1242,10 @@ fn assemble_candidates_from_object_ty<'cx, 'tcx>(
12421242
);
12431243
}
12441244

1245+
#[tracing::instrument(
1246+
level = "debug",
1247+
skip(selcx, candidate_set, ctor, env_predicates, potentially_unnormalized_candidates)
1248+
)]
12451249
fn assemble_candidates_from_predicates<'cx, 'tcx>(
12461250
selcx: &mut SelectionContext<'cx, 'tcx>,
12471251
obligation: &ProjectionTyObligation<'tcx>,
@@ -1250,8 +1254,6 @@ fn assemble_candidates_from_predicates<'cx, 'tcx>(
12501254
env_predicates: impl Iterator<Item = ty::Predicate<'tcx>>,
12511255
potentially_unnormalized_candidates: bool,
12521256
) {
1253-
debug!(?obligation, "assemble_candidates_from_predicates");
1254-
12551257
let infcx = selcx.infcx();
12561258
for predicate in env_predicates {
12571259
debug!(?predicate);
@@ -1287,13 +1289,12 @@ fn assemble_candidates_from_predicates<'cx, 'tcx>(
12871289
}
12881290
}
12891291

1292+
#[tracing::instrument(level = "debug", skip(selcx, obligation, candidate_set))]
12901293
fn assemble_candidates_from_impls<'cx, 'tcx>(
12911294
selcx: &mut SelectionContext<'cx, 'tcx>,
12921295
obligation: &ProjectionTyObligation<'tcx>,
12931296
candidate_set: &mut ProjectionTyCandidateSet<'tcx>,
12941297
) {
1295-
debug!("assemble_candidates_from_impls");
1296-
12971298
// If we are resolving `<T as TraitRef<...>>::Item == Type`,
12981299
// start out by selecting the predicate `T as TraitRef<...>`:
12991300
let poly_trait_ref = ty::Binder::dummy(obligation.predicate.trait_ref(selcx.tcx()));

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

Lines changed: 10 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -173,6 +173,9 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
173173

174174
let needs_infer = stack.obligation.predicate.has_infer_types_or_consts();
175175

176+
let sized_predicate = self.tcx().lang_items().sized_trait()
177+
== Some(stack.obligation.predicate.skip_binder().def_id());
178+
176179
// If there are STILL multiple candidates, we can further
177180
// reduce the list by dropping duplicates -- including
178181
// resolving specializations.
@@ -181,6 +184,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
181184
while i < candidates.len() {
182185
let is_dup = (0..candidates.len()).filter(|&j| i != j).any(|j| {
183186
self.candidate_should_be_dropped_in_favor_of(
187+
sized_predicate,
184188
&candidates[i],
185189
&candidates[j],
186190
needs_infer,
@@ -338,13 +342,12 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
338342
Ok(candidates)
339343
}
340344

345+
#[tracing::instrument(level = "debug", skip(self, candidates))]
341346
fn assemble_candidates_from_projected_tys(
342347
&mut self,
343348
obligation: &TraitObligation<'tcx>,
344349
candidates: &mut SelectionCandidateSet<'tcx>,
345350
) {
346-
debug!(?obligation, "assemble_candidates_from_projected_tys");
347-
348351
// Before we go into the whole placeholder thing, just
349352
// quickly check if the self-type is a projection at all.
350353
match obligation.predicate.skip_binder().trait_ref.self_ty().kind() {
@@ -369,12 +372,13 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
369372
/// supplied to find out whether it is listed among them.
370373
///
371374
/// Never affects the inference environment.
375+
#[tracing::instrument(level = "debug", skip(self, stack, candidates))]
372376
fn assemble_candidates_from_caller_bounds<'o>(
373377
&mut self,
374378
stack: &TraitObligationStack<'o, 'tcx>,
375379
candidates: &mut SelectionCandidateSet<'tcx>,
376380
) -> Result<(), SelectionError<'tcx>> {
377-
debug!(?stack.obligation, "assemble_candidates_from_caller_bounds");
381+
debug!(?stack.obligation);
378382

379383
let all_bounds = stack
380384
.obligation
@@ -876,14 +880,15 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
876880
};
877881
}
878882

883+
#[tracing::instrument(level = "debug", skip(self, obligation, candidates))]
879884
fn assemble_candidates_for_trait_alias(
880885
&mut self,
881886
obligation: &TraitObligation<'tcx>,
882887
candidates: &mut SelectionCandidateSet<'tcx>,
883888
) {
884889
// Okay to skip binder here because the tests we do below do not involve bound regions.
885890
let self_ty = obligation.self_ty().skip_binder();
886-
debug!(?self_ty, "assemble_candidates_for_trait_alias");
891+
debug!(?self_ty);
887892

888893
let def_id = obligation.predicate.def_id();
889894

@@ -894,21 +899,20 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
894899

895900
/// Assembles the trait which are built-in to the language itself:
896901
/// `Copy`, `Clone` and `Sized`.
902+
#[tracing::instrument(level = "debug", skip(self, candidates))]
897903
fn assemble_builtin_bound_candidates(
898904
&mut self,
899905
conditions: BuiltinImplConditions<'tcx>,
900906
candidates: &mut SelectionCandidateSet<'tcx>,
901907
) {
902908
match conditions {
903909
BuiltinImplConditions::Where(nested) => {
904-
debug!(?nested, "builtin_bound");
905910
candidates
906911
.vec
907912
.push(BuiltinCandidate { has_nested: !nested.skip_binder().is_empty() });
908913
}
909914
BuiltinImplConditions::None => {}
910915
BuiltinImplConditions::Ambiguous => {
911-
debug!("assemble_builtin_bound_candidates: ambiguous builtin");
912916
candidates.ambiguous = true;
913917
}
914918
}

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

Lines changed: 14 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -200,6 +200,7 @@ struct EvaluatedCandidate<'tcx> {
200200
}
201201

202202
/// When does the builtin impl for `T: Trait` apply?
203+
#[derive(Debug)]
203204
enum BuiltinImplConditions<'tcx> {
204205
/// The impl is conditional on `T1, T2, ...: Trait`.
205206
Where(ty::Binder<'tcx, Vec<Ty<'tcx>>>),
@@ -343,7 +344,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
343344
}
344345
Err(e) => Err(e),
345346
Ok(candidate) => {
346-
debug!(?candidate);
347+
debug!(?candidate, "confirmed");
347348
Ok(Some(candidate))
348349
}
349350
}
@@ -1476,6 +1477,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
14761477
/// See the comment for "SelectionCandidate" for more details.
14771478
fn candidate_should_be_dropped_in_favor_of(
14781479
&mut self,
1480+
sized_predicate: bool,
14791481
victim: &EvaluatedCandidate<'tcx>,
14801482
other: &EvaluatedCandidate<'tcx>,
14811483
needs_infer: bool,
@@ -1547,6 +1549,16 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
15471549
// Drop otherwise equivalent non-const fn pointer candidates
15481550
(FnPointerCandidate { .. }, FnPointerCandidate { is_const: false }) => true,
15491551

1552+
// If obligation is a sized predicate or the where-clause bound is
1553+
// global, prefer the projection or object candidate. See issue
1554+
// #50825 and #89352.
1555+
(ObjectCandidate(_) | ProjectionCandidate(_), ParamCandidate(ref cand)) => {
1556+
sized_predicate || is_global(cand)
1557+
}
1558+
(ParamCandidate(ref cand), ObjectCandidate(_) | ProjectionCandidate(_)) => {
1559+
!(sized_predicate || is_global(cand))
1560+
}
1561+
15501562
// Global bounds from the where clause should be ignored
15511563
// here (see issue #50825). Otherwise, we have a where
15521564
// clause so don't go around looking for impls.
@@ -1562,15 +1574,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
15621574
| BuiltinUnsizeCandidate
15631575
| TraitUpcastingUnsizeCandidate(_)
15641576
| BuiltinCandidate { .. }
1565-
| TraitAliasCandidate(..)
1566-
| ObjectCandidate(_)
1567-
| ProjectionCandidate(_),
1577+
| TraitAliasCandidate(..),
15681578
) => !is_global(cand),
1569-
(ObjectCandidate(_) | ProjectionCandidate(_), ParamCandidate(ref cand)) => {
1570-
// Prefer these to a global where-clause bound
1571-
// (see issue #50825).
1572-
is_global(cand)
1573-
}
15741579
(
15751580
ImplCandidate(_)
15761581
| ClosureCandidate

‎compiler/rustc_typeck/src/astconv/mod.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -286,7 +286,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
286286
/// Given the type/lifetime/const arguments provided to some path (along with
287287
/// an implicit `Self`, if this is a trait reference), returns the complete
288288
/// set of substitutions. This may involve applying defaulted type parameters.
289-
/// Also returns back constraints on associated types.
289+
/// Constraints on associated typess are created from `create_assoc_bindings_for_generic_args`.
290290
///
291291
/// Example:
292292
///
@@ -300,7 +300,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
300300
/// which will have been resolved to a `def_id`
301301
/// 3. The `generic_args` contains info on the `<...>` contents. The `usize` type
302302
/// parameters are returned in the `SubstsRef`, the associated type bindings like
303-
/// `Output = u32` are returned in the `Vec<ConvertedBinding...>` result.
303+
/// `Output = u32` are returned from `create_assoc_bindings_for_generic_args`.
304304
///
305305
/// Note that the type listing given here is *exactly* what the user provided.
306306
///

‎compiler/rustc_typeck/src/check/method/mod.rs

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -360,6 +360,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
360360
let (obligation, substs) =
361361
self.obligation_for_method(span, trait_def_id, self_ty, opt_input_types);
362362

363+
debug!(?obligation);
364+
363365
// Now we want to know if this can be matched
364366
if !self.predicate_may_hold(&obligation) {
365367
debug!("--> Cannot match obligation");

‎src/test/ui/associated-types/substs-ppaux.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -25,7 +25,7 @@ fn foo<'z>() where &'z (): Sized {
2525
let x: () = <i8 as Foo<'static, 'static, u32>>::bar::<'static, char>;
2626
//[verbose]~^ ERROR mismatched types
2727
//[verbose]~| expected unit type `()`
28-
//[verbose]~| found fn item `fn() {<i8 as Foo<ReStatic, ReStatic>>::bar::<ReStatic, char>}`
28+
//[verbose]~| found fn item `fn() {<i8 as Foo<ReStatic, ReStatic, u32>>::bar::<ReStatic, char>}`
2929
//[normal]~^^^^ ERROR mismatched types
3030
//[normal]~| expected unit type `()`
3131
//[normal]~| found fn item `fn() {<i8 as Foo<'static, 'static>>::bar::<'static, char>}`

‎src/test/ui/associated-types/substs-ppaux.verbose.stderr

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -20,15 +20,15 @@ error[E0308]: mismatched types
2020
--> $DIR/substs-ppaux.rs:25:17
2121
|
2222
LL | fn bar<'a, T>() where T: 'a {}
23-
| --------------------------- fn() {<i8 as Foo<ReStatic, ReStatic>>::bar::<ReStatic, char>} defined here
23+
| --------------------------- fn() {<i8 as Foo<ReStatic, ReStatic, u32>>::bar::<ReStatic, char>} defined here
2424
...
2525
LL | let x: () = <i8 as Foo<'static, 'static, u32>>::bar::<'static, char>;
2626
| -- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `()`, found fn item
2727
| |
2828
| expected due to this
2929
|
3030
= note: expected unit type `()`
31-
found fn item `fn() {<i8 as Foo<ReStatic, ReStatic>>::bar::<ReStatic, char>}`
31+
found fn item `fn() {<i8 as Foo<ReStatic, ReStatic, u32>>::bar::<ReStatic, char>}`
3232
help: use parentheses to call this function
3333
|
3434
LL | let x: () = <i8 as Foo<'static, 'static, u32>>::bar::<'static, char>();

‎src/test/ui/generic-associated-types/issue-89352.rs

Lines changed: 32 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,32 @@
1+
// check-pass
2+
3+
#![feature(generic_associated_types)]
4+
5+
use std::marker::PhantomData;
6+
7+
pub trait GenAssoc<T> {
8+
type Iter<'at>;
9+
fn iter(&self) -> Self::Iter<'_>;
10+
fn reborrow<'longt: 'shortt, 'shortt>(iter: Self::Iter<'longt>) -> Self::Iter<'shortt>;
11+
}
12+
13+
pub struct Wrapper<'a, T: 'a, A: GenAssoc<T>> {
14+
a: A::Iter<'a>,
15+
_p: PhantomData<T>,
16+
}
17+
18+
impl<'ai, T: 'ai, A: GenAssoc<T>> GenAssoc<T> for Wrapper<'ai, T, A>
19+
where
20+
A::Iter<'ai>: Clone,
21+
{
22+
type Iter<'b> = ();
23+
fn iter<'s>(&'s self) -> Self::Iter<'s> {
24+
let a = A::reborrow::<'ai, 's>(self.a.clone());
25+
}
26+
27+
fn reborrow<'long: 'short, 'short>(iter: Self::Iter<'long>) -> Self::Iter<'short> {
28+
()
29+
}
30+
}
31+
32+
fn main() {}

‎src/test/ui/nll/ty-outlives/projection-no-regions-closure.stderr

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,7 @@ LL | with_signature(x, |mut y| Box::new(y.next()))
66
|
77
= note: defining type: no_region::<'_#1r, T>::{closure#0} with closure substs [
88
i32,
9-
extern "rust-call" fn((std::boxed::Box<T>,)) -> std::boxed::Box<(dyn Anything + '_#2r)>,
9+
extern "rust-call" fn((std::boxed::Box<T, std::alloc::Global>,)) -> std::boxed::Box<(dyn Anything + '_#2r), std::alloc::Global>,
1010
(),
1111
]
1212
= note: number of external vids: 3
@@ -42,7 +42,7 @@ LL | with_signature(x, |mut y| Box::new(y.next()))
4242
|
4343
= note: defining type: correct_region::<'_#1r, T>::{closure#0} with closure substs [
4444
i32,
45-
extern "rust-call" fn((std::boxed::Box<T>,)) -> std::boxed::Box<(dyn Anything + '_#2r)>,
45+
extern "rust-call" fn((std::boxed::Box<T, std::alloc::Global>,)) -> std::boxed::Box<(dyn Anything + '_#2r), std::alloc::Global>,
4646
(),
4747
]
4848
= note: number of external vids: 3
@@ -69,7 +69,7 @@ LL | with_signature(x, |mut y| Box::new(y.next()))
6969
|
7070
= note: defining type: wrong_region::<'_#1r, '_#2r, T>::{closure#0} with closure substs [
7171
i32,
72-
extern "rust-call" fn((std::boxed::Box<T>,)) -> std::boxed::Box<(dyn Anything + '_#3r)>,
72+
extern "rust-call" fn((std::boxed::Box<T, std::alloc::Global>,)) -> std::boxed::Box<(dyn Anything + '_#3r), std::alloc::Global>,
7373
(),
7474
]
7575
= note: number of external vids: 4
@@ -105,7 +105,7 @@ LL | with_signature(x, |mut y| Box::new(y.next()))
105105
|
106106
= note: defining type: outlives_region::<'_#1r, '_#2r, T>::{closure#0} with closure substs [
107107
i32,
108-
extern "rust-call" fn((std::boxed::Box<T>,)) -> std::boxed::Box<(dyn Anything + '_#3r)>,
108+
extern "rust-call" fn((std::boxed::Box<T, std::alloc::Global>,)) -> std::boxed::Box<(dyn Anything + '_#3r), std::alloc::Global>,
109109
(),
110110
]
111111
= note: number of external vids: 4

‎src/test/ui/nll/ty-outlives/ty-param-closure-outlives-from-return-type.stderr

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,7 @@ LL | with_signature(x, |y| y)
66
|
77
= note: defining type: no_region::<'_#1r, T>::{closure#0} with closure substs [
88
i32,
9-
extern "rust-call" fn((std::boxed::Box<T>,)) -> std::boxed::Box<(dyn std::fmt::Debug + '_#2r)>,
9+
extern "rust-call" fn((std::boxed::Box<T, std::alloc::Global>,)) -> std::boxed::Box<(dyn std::fmt::Debug + '_#2r), std::alloc::Global>,
1010
(),
1111
]
1212
= note: number of external vids: 3

0 commit comments

Comments
 (0)