Skip to content

Commit 58d8e54

Browse files
lcnrlcnr
committed
Merge branch 'eagerly-normalize-added-goals' into next-solver-bootstrap-hack
2 parents 054c1e3 + 9aa8308 commit 58d8e54

File tree

12 files changed

+253
-63
lines changed

12 files changed

+253
-63
lines changed

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

Lines changed: 3 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -120,17 +120,14 @@ impl<'tcx> Predicate<'tcx> {
120120
#[inline]
121121
pub fn allow_normalization(self) -> bool {
122122
match self.kind().skip_binder() {
123-
PredicateKind::Clause(ClauseKind::WellFormed(_)) => false,
124-
// `NormalizesTo` is only used in the new solver, so this shouldn't
125-
// matter. Normalizing `term` would be 'wrong' however, as it changes whether
126-
// `normalizes-to(<T as Trait>::Assoc, <T as Trait>::Assoc)` holds.
127-
PredicateKind::NormalizesTo(..) => false,
123+
PredicateKind::Clause(ClauseKind::WellFormed(_))
124+
| PredicateKind::AliasRelate(..)
125+
| PredicateKind::NormalizesTo(..) => false,
128126
PredicateKind::Clause(ClauseKind::Trait(_))
129127
| PredicateKind::Clause(ClauseKind::RegionOutlives(_))
130128
| PredicateKind::Clause(ClauseKind::TypeOutlives(_))
131129
| PredicateKind::Clause(ClauseKind::Projection(_))
132130
| PredicateKind::Clause(ClauseKind::ConstArgHasType(..))
133-
| PredicateKind::AliasRelate(..)
134131
| PredicateKind::ObjectSafe(_)
135132
| PredicateKind::Subtype(_)
136133
| PredicateKind::Coerce(_)

‎compiler/rustc_trait_selection/src/solve/alias_relate.rs

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -28,6 +28,7 @@ impl<'tcx> EvalCtxt<'_, InferCtxt<'tcx>> {
2828
) -> QueryResult<'tcx> {
2929
let tcx = self.tcx();
3030
let Goal { param_env, predicate: (lhs, rhs, direction) } = goal;
31+
debug_assert!(lhs.to_alias_term().is_some() || rhs.to_alias_term().is_some());
3132

3233
// Structurally normalize the lhs.
3334
let lhs = if let Some(alias) = lhs.to_alias_term() {

‎compiler/rustc_trait_selection/src/solve/eval_ctxt/mod.rs

Lines changed: 75 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -16,12 +16,15 @@ use rustc_middle::traits::solve::{
1616
inspect, CanonicalInput, CanonicalResponse, Certainty, PredefinedOpaquesData, QueryResult,
1717
};
1818
use rustc_middle::traits::specialization_graph;
19+
use rustc_middle::ty::AliasRelationDirection;
20+
use rustc_middle::ty::TypeFolder;
1921
use rustc_middle::ty::{
2022
self, InferCtxtLike, OpaqueTypeKey, Ty, TyCtxt, TypeFoldable, TypeSuperVisitable,
2123
TypeVisitable, TypeVisitableExt, TypeVisitor,
2224
};
2325
use rustc_session::config::DumpSolverProofTree;
2426
use rustc_span::DUMMY_SP;
27+
use rustc_type_ir::fold::TypeSuperFoldable;
2528
use rustc_type_ir::{self as ir, CanonicalVarValues, Interner};
2629
use rustc_type_ir_macros::{Lift_Generic, TypeFoldable_Generic, TypeVisitable_Generic};
2730

@@ -468,13 +471,23 @@ impl<'a, 'tcx> EvalCtxt<'a, InferCtxt<'tcx>> {
468471
}
469472

470473
#[instrument(level = "trace", skip(self))]
471-
pub(super) fn add_normalizes_to_goal(&mut self, goal: Goal<'tcx, ty::NormalizesTo<'tcx>>) {
474+
pub(super) fn add_normalizes_to_goal(&mut self, mut goal: Goal<'tcx, ty::NormalizesTo<'tcx>>) {
475+
goal.predicate = goal
476+
.predicate
477+
.fold_with(&mut ReplaceAliasWithInfer { ecx: self, param_env: goal.param_env });
472478
self.inspect.add_normalizes_to_goal(self.infcx, self.max_input_universe, goal);
473479
self.nested_goals.normalizes_to_goals.push(goal);
474480
}
475481

476482
#[instrument(level = "debug", skip(self))]
477-
pub(super) fn add_goal(&mut self, source: GoalSource, goal: Goal<'tcx, ty::Predicate<'tcx>>) {
483+
pub(super) fn add_goal(
484+
&mut self,
485+
source: GoalSource,
486+
mut goal: Goal<'tcx, ty::Predicate<'tcx>>,
487+
) {
488+
goal.predicate = goal
489+
.predicate
490+
.fold_with(&mut ReplaceAliasWithInfer { ecx: self, param_env: goal.param_env });
478491
self.inspect.add_goal(self.infcx, self.max_input_universe, source, goal);
479492
self.nested_goals.goals.push((source, goal));
480493
}
@@ -1101,3 +1114,63 @@ impl<'tcx> EvalCtxt<'_, InferCtxt<'tcx>> {
11011114
});
11021115
}
11031116
}
1117+
1118+
/// Eagerly replace aliases with inference variables, emitting `AliasRelate`
1119+
/// goals, used when adding goals to the `EvalCtxt`. We compute the
1120+
/// `AliasRelate` goals before evaluating the actual goal to get all the
1121+
/// constraints we can.
1122+
///
1123+
/// This is a performance optimization to more eagerly detect cycles during trait
1124+
/// solving. See tests/ui/traits/next-solver/cycles/cycle-modulo-ambig-aliases.rs.
1125+
struct ReplaceAliasWithInfer<'me, 'a, 'tcx> {
1126+
ecx: &'me mut EvalCtxt<'a, InferCtxt<'tcx>>,
1127+
param_env: ty::ParamEnv<'tcx>,
1128+
}
1129+
1130+
impl<'tcx> TypeFolder<TyCtxt<'tcx>> for ReplaceAliasWithInfer<'_, '_, 'tcx> {
1131+
fn interner(&self) -> TyCtxt<'tcx> {
1132+
self.ecx.tcx()
1133+
}
1134+
1135+
fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
1136+
match *ty.kind() {
1137+
ty::Alias(..) if !ty.has_escaping_bound_vars() => {
1138+
let infer_ty = self.ecx.next_ty_infer();
1139+
let normalizes_to = ty::PredicateKind::AliasRelate(
1140+
ty.into(),
1141+
infer_ty.into(),
1142+
AliasRelationDirection::Equate,
1143+
);
1144+
self.ecx.add_goal(
1145+
GoalSource::Misc,
1146+
Goal::new(self.interner(), self.param_env, normalizes_to),
1147+
);
1148+
infer_ty
1149+
}
1150+
_ => ty.super_fold_with(self),
1151+
}
1152+
}
1153+
1154+
fn fold_const(&mut self, ct: ty::Const<'tcx>) -> ty::Const<'tcx> {
1155+
match ct.kind() {
1156+
ty::ConstKind::Unevaluated(..) if !ct.has_escaping_bound_vars() => {
1157+
let infer_ct = self.ecx.next_const_infer(ct.ty());
1158+
let normalizes_to = ty::PredicateKind::AliasRelate(
1159+
ct.into(),
1160+
infer_ct.into(),
1161+
AliasRelationDirection::Equate,
1162+
);
1163+
self.ecx.add_goal(
1164+
GoalSource::Misc,
1165+
Goal::new(self.interner(), self.param_env, normalizes_to),
1166+
);
1167+
infer_ct
1168+
}
1169+
_ => ct.super_fold_with(self),
1170+
}
1171+
}
1172+
1173+
fn fold_predicate(&mut self, predicate: ty::Predicate<'tcx>) -> ty::Predicate<'tcx> {
1174+
if predicate.allow_normalization() { predicate.super_fold_with(self) } else { predicate }
1175+
}
1176+
}

‎compiler/rustc_trait_selection/src/solve/inspect/analyse.rs

Lines changed: 44 additions & 46 deletions
Original file line numberDiff line numberDiff line change
@@ -89,10 +89,8 @@ impl<'tcx> NormalizesToTermHack<'tcx> {
8989
pub struct InspectCandidate<'a, 'tcx> {
9090
goal: &'a InspectGoal<'a, 'tcx>,
9191
kind: inspect::ProbeKind<TyCtxt<'tcx>>,
92-
nested_goals:
93-
Vec<(GoalSource, inspect::CanonicalState<TyCtxt<'tcx>, Goal<'tcx, ty::Predicate<'tcx>>>)>,
92+
steps: Vec<&'a inspect::ProbeStep<TyCtxt<'tcx>>>,
9493
final_state: inspect::CanonicalState<TyCtxt<'tcx>, ()>,
95-
impl_args: Option<inspect::CanonicalState<TyCtxt<'tcx>, ty::GenericArgsRef<'tcx>>>,
9694
result: QueryResult<'tcx>,
9795
shallow_certainty: Certainty,
9896
}
@@ -148,7 +146,7 @@ impl<'a, 'tcx> InspectCandidate<'a, 'tcx> {
148146
#[instrument(
149147
level = "debug",
150148
skip_all,
151-
fields(goal = ?self.goal.goal, nested_goals = ?self.nested_goals)
149+
fields(goal = ?self.goal.goal, steps = ?self.steps)
152150
)]
153151
pub fn instantiate_nested_goals_and_opt_impl_args(
154152
&self,
@@ -157,22 +155,35 @@ impl<'a, 'tcx> InspectCandidate<'a, 'tcx> {
157155
let infcx = self.goal.infcx;
158156
let param_env = self.goal.goal.param_env;
159157
let mut orig_values = self.goal.orig_values.to_vec();
160-
let instantiated_goals: Vec<_> = self
161-
.nested_goals
162-
.iter()
163-
.map(|(source, goal)| {
164-
(
165-
*source,
158+
159+
let mut instantiated_goals = vec![];
160+
let mut opt_impl_args = None;
161+
for step in &self.steps {
162+
match **step {
163+
inspect::ProbeStep::AddGoal(source, goal) => instantiated_goals.push((
164+
source,
166165
canonical::instantiate_canonical_state(
167166
infcx,
168167
span,
169168
param_env,
170169
&mut orig_values,
171-
*goal,
170+
goal,
172171
),
173-
)
174-
})
175-
.collect();
172+
)),
173+
inspect::ProbeStep::RecordImplArgs { impl_args } => {
174+
opt_impl_args = Some(canonical::instantiate_canonical_state(
175+
infcx,
176+
span,
177+
param_env,
178+
&mut orig_values,
179+
impl_args,
180+
));
181+
}
182+
inspect::ProbeStep::MakeCanonicalResponse { .. }
183+
| inspect::ProbeStep::EvaluateGoals(_)
184+
| inspect::ProbeStep::NestedProbe(_) => unreachable!(),
185+
}
186+
}
176187

177188
let () = canonical::instantiate_canonical_state(
178189
infcx,
@@ -182,24 +193,16 @@ impl<'a, 'tcx> InspectCandidate<'a, 'tcx> {
182193
self.final_state,
183194
);
184195

185-
let impl_args = self.impl_args.map(|impl_args| {
186-
canonical::instantiate_canonical_state(
187-
infcx,
188-
span,
189-
param_env,
190-
&mut orig_values,
191-
impl_args,
192-
)
193-
.fold_with(&mut EagerResolver::new(infcx))
194-
});
195-
196196
if let Some(term_hack) = self.goal.normalizes_to_term_hack {
197197
// FIXME: We ignore the expected term of `NormalizesTo` goals
198198
// when computing the result of its candidates. This is
199199
// scuffed.
200200
let _ = term_hack.constrain(infcx, span, param_env);
201201
}
202202

203+
let opt_impl_args =
204+
opt_impl_args.map(|impl_args| impl_args.fold_with(&mut EagerResolver::new(infcx)));
205+
203206
let goals = instantiated_goals
204207
.into_iter()
205208
.map(|(source, goal)| match goal.predicate.kind().no_bound_vars() {
@@ -249,7 +252,7 @@ impl<'a, 'tcx> InspectCandidate<'a, 'tcx> {
249252
})
250253
.collect();
251254

252-
(goals, impl_args)
255+
(goals, opt_impl_args)
253256
}
254257

255258
/// Visit all nested goals of this candidate, rolling back
@@ -279,17 +282,20 @@ impl<'a, 'tcx> InspectGoal<'a, 'tcx> {
279282
fn candidates_recur(
280283
&'a self,
281284
candidates: &mut Vec<InspectCandidate<'a, 'tcx>>,
282-
nested_goals: &mut Vec<(
283-
GoalSource,
284-
inspect::CanonicalState<TyCtxt<'tcx>, Goal<'tcx, ty::Predicate<'tcx>>>,
285-
)>,
286-
probe: &inspect::Probe<TyCtxt<'tcx>>,
285+
steps: &mut Vec<&'a inspect::ProbeStep<TyCtxt<'tcx>>>,
286+
probe: &'a inspect::Probe<TyCtxt<'tcx>>,
287287
) {
288288
let mut shallow_certainty = None;
289-
let mut impl_args = None;
290289
for step in &probe.steps {
291290
match *step {
292-
inspect::ProbeStep::AddGoal(source, goal) => nested_goals.push((source, goal)),
291+
inspect::ProbeStep::AddGoal(..) | inspect::ProbeStep::RecordImplArgs { .. } => {
292+
steps.push(step)
293+
}
294+
inspect::ProbeStep::MakeCanonicalResponse { shallow_certainty: c } => {
295+
assert_eq!(shallow_certainty.replace(c), None);
296+
}
297+
// We ignore evaluate goals steps for no.
298+
inspect::ProbeStep::EvaluateGoals(_) => {}
293299
inspect::ProbeStep::NestedProbe(ref probe) => {
294300
match probe.kind {
295301
// These never assemble candidates for the goal we're trying to solve.
@@ -305,19 +311,12 @@ impl<'a, 'tcx> InspectGoal<'a, 'tcx> {
305311
// Nested probes have to prove goals added in their parent
306312
// but do not leak them, so we truncate the added goals
307313
// afterwards.
308-
let num_goals = nested_goals.len();
309-
self.candidates_recur(candidates, nested_goals, probe);
310-
nested_goals.truncate(num_goals);
314+
let num_steps = steps.len();
315+
self.candidates_recur(candidates, steps, probe);
316+
steps.truncate(num_steps);
311317
}
312318
}
313319
}
314-
inspect::ProbeStep::MakeCanonicalResponse { shallow_certainty: c } => {
315-
assert_eq!(shallow_certainty.replace(c), None);
316-
}
317-
inspect::ProbeStep::RecordImplArgs { impl_args: i } => {
318-
assert_eq!(impl_args.replace(i), None);
319-
}
320-
inspect::ProbeStep::EvaluateGoals(_) => (),
321320
}
322321
}
323322

@@ -339,11 +338,10 @@ impl<'a, 'tcx> InspectGoal<'a, 'tcx> {
339338
candidates.push(InspectCandidate {
340339
goal: self,
341340
kind: probe.kind,
342-
nested_goals: nested_goals.clone(),
341+
steps: steps.clone(),
343342
final_state: probe.final_state,
344-
result,
345343
shallow_certainty,
346-
impl_args,
344+
result,
347345
});
348346
}
349347
}

‎tests/ui/coherence/coherence-overlap-unnormalizable-projection-1.next.stderr

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -12,7 +12,7 @@ LL | impl<T> Trait for Box<T> {}
1212
| ^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `Box<_>`
1313
|
1414
= note: downstream crates may implement trait `WithAssoc<'a>` for type `std::boxed::Box<_>`
15-
= note: downstream crates may implement trait `WhereBound` for type `std::boxed::Box<<std::boxed::Box<_> as WithAssoc<'a>>::Assoc>`
15+
= note: downstream crates may implement trait `WhereBound` for type `std::boxed::Box<_>`
1616

1717
error: aborting due to 1 previous error
1818

‎tests/ui/coherence/occurs-check/opaques.next.stderr

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,7 @@ error[E0282]: type annotations needed
1111
--> $DIR/opaques.rs:13:20
1212
|
1313
LL | pub fn cast<T>(x: Container<Alias<T>, T>) -> Container<T, T> {
14-
| ^ cannot infer type for associated type `<T as Trait<T>>::Assoc`
14+
| ^ cannot infer type
1515

1616
error: aborting due to 2 previous errors
1717

‎tests/ui/diagnostic_namespace/do_not_recommend/as_expression.next.stderr

Lines changed: 18 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -16,6 +16,22 @@ LL | where
1616
LL | T: AsExpression<Self::SqlType>,
1717
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Foo::check`
1818

19-
error: aborting due to 1 previous error
19+
error[E0277]: the trait bound `&str: AsExpression<Integer>` is not satisfied
20+
--> $DIR/as_expression.rs:57:15
21+
|
22+
LL | SelectInt.check("bar");
23+
| ^^^^^ the trait `AsExpression<Integer>` is not implemented for `&str`
24+
|
25+
= help: the trait `AsExpression<Text>` is implemented for `&str`
26+
= help: for that trait implementation, expected `Text`, found `Integer`
27+
28+
error[E0271]: type mismatch resolving `<&str as AsExpression<<SelectInt as Expression>::SqlType>>::Expression == _`
29+
--> $DIR/as_expression.rs:57:5
30+
|
31+
LL | SelectInt.check("bar");
32+
| ^^^^^^^^^^^^^^^^^^^^^^ types differ
33+
34+
error: aborting due to 3 previous errors
2035

21-
For more information about this error, try `rustc --explain E0277`.
36+
Some errors have detailed explanations: E0271, E0277.
37+
For more information about an error, try `rustc --explain E0271`.

‎tests/ui/diagnostic_namespace/do_not_recommend/as_expression.rs

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -55,6 +55,7 @@ impl<T> Foo for T where T: Expression {}
5555

5656
fn main() {
5757
SelectInt.check("bar");
58-
//[next]~^ ERROR the trait bound `&str: AsExpression<<SelectInt as Expression>::SqlType>` is not satisfied
59-
//[current]~^^ ERROR the trait bound `&str: AsExpression<Integer>` is not satisfied
58+
//~^ ERROR the trait bound `&str: AsExpression<Integer>` is not satisfied
59+
//[next]~| the trait bound `&str: AsExpression<<SelectInt as Expression>::SqlType>` is not satisfied
60+
//[next]~| type mismatch
6061
}

‎tests/ui/traits/next-solver/canonical/const-region-infer-to-static-in-binder.stderr

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,8 @@
1-
error[E0284]: type annotations needed: cannot satisfy `the constant `{ || {} }` can be evaluated`
1+
error[E0284]: type annotations needed: cannot satisfy `{ || {} } == _`
22
--> $DIR/const-region-infer-to-static-in-binder.rs:4:10
33
|
44
LL | struct X<const FN: fn() = { || {} }>;
5-
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot satisfy `the constant `{ || {} }` can be evaluated`
5+
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot satisfy `{ || {} } == _`
66

77
error: using function pointers as const generic parameters is forbidden
88
--> $DIR/const-region-infer-to-static-in-binder.rs:4:20

0 commit comments

Comments
 (0)