|
2 | 2 |
|
3 | 3 | pub(super) mod structural_traits; |
4 | 4 |
|
| 5 | +use std::ops::ControlFlow; |
| 6 | + |
5 | 7 | use derive_where::derive_where; |
6 | 8 | use rustc_type_ir::inherent::*; |
7 | 9 | use rustc_type_ir::lang_items::TraitSolverLangItem; |
8 | 10 | use rustc_type_ir::{ |
9 | | - self as ty, Interner, TypeFoldable, TypeVisitableExt as _, TypingMode, Upcast as _, elaborate, |
| 11 | + self as ty, Interner, TypeFoldable, TypeSuperVisitable, TypeVisitable, TypeVisitableExt as _, |
| 12 | + TypeVisitor, TypingMode, Upcast as _, elaborate, |
10 | 13 | }; |
11 | 14 | use tracing::{debug, instrument}; |
12 | 15 |
|
13 | | -use super::has_only_region_constraints; |
14 | 16 | use super::trait_goals::TraitGoalProvenVia; |
| 17 | +use super::{has_only_region_constraints, inspect}; |
15 | 18 | use crate::delegate::SolverDelegate; |
16 | 19 | use crate::solve::inspect::ProbeKind; |
17 | 20 | use crate::solve::{ |
18 | 21 | BuiltinImplSource, CandidateSource, CanonicalResponse, Certainty, EvalCtxt, Goal, GoalSource, |
19 | | - MaybeCause, NoSolution, QueryResult, |
| 22 | + MaybeCause, NoSolution, ParamEnvSource, QueryResult, |
20 | 23 | }; |
21 | 24 |
|
22 | 25 | enum AliasBoundKind { |
|
49 | 52 |
|
50 | 53 | fn trait_def_id(self, cx: I) -> I::DefId; |
51 | 54 |
|
52 | | - /// Try equating an assumption predicate against a goal's predicate. If it |
53 | | - /// holds, then execute the `then` callback, which should do any additional |
54 | | - /// work, then produce a response (typically by executing |
55 | | - /// [`EvalCtxt::evaluate_added_goals_and_make_canonical_response`]). |
56 | | - fn probe_and_match_goal_against_assumption( |
57 | | - ecx: &mut EvalCtxt<'_, D>, |
58 | | - source: CandidateSource<I>, |
59 | | - goal: Goal<I, Self>, |
60 | | - assumption: I::Clause, |
61 | | - then: impl FnOnce(&mut EvalCtxt<'_, D>) -> QueryResult<I>, |
62 | | - ) -> Result<Candidate<I>, NoSolution>; |
63 | | - |
64 | 55 | /// Consider a clause, which consists of a "assumption" and some "requirements", |
65 | 56 | /// to satisfy a goal. If the requirements hold, then attempt to satisfy our |
66 | 57 | /// goal by equating it with the assumption. |
@@ -119,6 +110,67 @@ where |
119 | 110 | alias_ty: ty::AliasTy<I>, |
120 | 111 | ) -> Vec<Candidate<I>>; |
121 | 112 |
|
| 113 | + fn probe_and_consider_param_env_candidate( |
| 114 | + ecx: &mut EvalCtxt<'_, D>, |
| 115 | + goal: Goal<I, Self>, |
| 116 | + assumption: I::Clause, |
| 117 | + ) -> Result<Candidate<I>, NoSolution> { |
| 118 | + Self::fast_reject_assumption(ecx, goal, assumption)?; |
| 119 | + |
| 120 | + ecx.probe(|candidate: &Result<Candidate<I>, NoSolution>| match candidate { |
| 121 | + Ok(candidate) => inspect::ProbeKind::TraitCandidate { |
| 122 | + source: candidate.source, |
| 123 | + result: Ok(candidate.result), |
| 124 | + }, |
| 125 | + Err(NoSolution) => inspect::ProbeKind::TraitCandidate { |
| 126 | + source: CandidateSource::ParamEnv(ParamEnvSource::Global), |
| 127 | + result: Err(NoSolution), |
| 128 | + }, |
| 129 | + }) |
| 130 | + .enter(|ecx| { |
| 131 | + Self::match_assumption(ecx, goal, assumption)?; |
| 132 | + let source = ecx.characterize_param_env_assumption(goal.param_env, assumption)?; |
| 133 | + Ok(Candidate { |
| 134 | + source, |
| 135 | + result: ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)?, |
| 136 | + }) |
| 137 | + }) |
| 138 | + } |
| 139 | + |
| 140 | + /// Try equating an assumption predicate against a goal's predicate. If it |
| 141 | + /// holds, then execute the `then` callback, which should do any additional |
| 142 | + /// work, then produce a response (typically by executing |
| 143 | + /// [`EvalCtxt::evaluate_added_goals_and_make_canonical_response`]). |
| 144 | + fn probe_and_match_goal_against_assumption( |
| 145 | + ecx: &mut EvalCtxt<'_, D>, |
| 146 | + source: CandidateSource<I>, |
| 147 | + goal: Goal<I, Self>, |
| 148 | + assumption: I::Clause, |
| 149 | + then: impl FnOnce(&mut EvalCtxt<'_, D>) -> QueryResult<I>, |
| 150 | + ) -> Result<Candidate<I>, NoSolution> { |
| 151 | + Self::fast_reject_assumption(ecx, goal, assumption)?; |
| 152 | + |
| 153 | + ecx.probe_trait_candidate(source).enter(|ecx| { |
| 154 | + Self::match_assumption(ecx, goal, assumption)?; |
| 155 | + then(ecx) |
| 156 | + }) |
| 157 | + } |
| 158 | + |
| 159 | + /// Try to reject the assumption based off of simple heuristics, such as [`ty::ClauseKind`] |
| 160 | + /// and `DefId`. |
| 161 | + fn fast_reject_assumption( |
| 162 | + ecx: &mut EvalCtxt<'_, D>, |
| 163 | + goal: Goal<I, Self>, |
| 164 | + assumption: I::Clause, |
| 165 | + ) -> Result<(), NoSolution>; |
| 166 | + |
| 167 | + /// Relate the goal and assumption. |
| 168 | + fn match_assumption( |
| 169 | + ecx: &mut EvalCtxt<'_, D>, |
| 170 | + goal: Goal<I, Self>, |
| 171 | + assumption: I::Clause, |
| 172 | + ) -> Result<(), NoSolution>; |
| 173 | + |
122 | 174 | fn consider_impl_candidate( |
123 | 175 | ecx: &mut EvalCtxt<'_, D>, |
124 | 176 | goal: Goal<I, Self>, |
@@ -500,14 +552,8 @@ where |
500 | 552 | goal: Goal<I, G>, |
501 | 553 | candidates: &mut Vec<Candidate<I>>, |
502 | 554 | ) { |
503 | | - for (i, assumption) in goal.param_env.caller_bounds().iter().enumerate() { |
504 | | - candidates.extend(G::probe_and_consider_implied_clause( |
505 | | - self, |
506 | | - CandidateSource::ParamEnv(i), |
507 | | - goal, |
508 | | - assumption, |
509 | | - [], |
510 | | - )); |
| 555 | + for assumption in goal.param_env.caller_bounds().iter() { |
| 556 | + candidates.extend(G::probe_and_consider_param_env_candidate(self, goal, assumption)); |
511 | 557 | } |
512 | 558 | } |
513 | 559 |
|
@@ -943,4 +989,88 @@ where |
943 | 989 | } |
944 | 990 | } |
945 | 991 | } |
| 992 | + |
| 993 | + /// Compute whether a param-env assumption is global or non-global after normalizing it. |
| 994 | + /// |
| 995 | + /// This is necessary because, for example, given: |
| 996 | + /// |
| 997 | + /// ```ignore,rust |
| 998 | + /// where |
| 999 | + /// T: Trait<Assoc = u32>, |
| 1000 | + /// i32: From<T::Assoc>, |
| 1001 | + /// ``` |
| 1002 | + /// |
| 1003 | + /// The `i32: From<T::Assoc>` bound is non-global before normalization, but is global after. |
| 1004 | + /// Since the old trait solver normalized param-envs eagerly, we want to emulate this |
| 1005 | + /// behavior lazily. |
| 1006 | + fn characterize_param_env_assumption( |
| 1007 | + &mut self, |
| 1008 | + param_env: I::ParamEnv, |
| 1009 | + assumption: I::Clause, |
| 1010 | + ) -> Result<CandidateSource<I>, NoSolution> { |
| 1011 | + // FIXME: This should be fixed, but it also requires changing the behavior |
| 1012 | + // in the old solver which is currently relied on. |
| 1013 | + if assumption.has_bound_vars() { |
| 1014 | + return Ok(CandidateSource::ParamEnv(ParamEnvSource::NonGlobal)); |
| 1015 | + } |
| 1016 | + |
| 1017 | + match assumption.visit_with(&mut FindParamInClause { ecx: self, param_env }) { |
| 1018 | + ControlFlow::Break(Err(NoSolution)) => Err(NoSolution), |
| 1019 | + ControlFlow::Break(Ok(())) => Ok(CandidateSource::ParamEnv(ParamEnvSource::NonGlobal)), |
| 1020 | + ControlFlow::Continue(()) => Ok(CandidateSource::ParamEnv(ParamEnvSource::Global)), |
| 1021 | + } |
| 1022 | + } |
| 1023 | +} |
| 1024 | + |
| 1025 | +struct FindParamInClause<'a, 'b, D: SolverDelegate<Interner = I>, I: Interner> { |
| 1026 | + ecx: &'a mut EvalCtxt<'b, D>, |
| 1027 | + param_env: I::ParamEnv, |
| 1028 | +} |
| 1029 | + |
| 1030 | +impl<D, I> TypeVisitor<I> for FindParamInClause<'_, '_, D, I> |
| 1031 | +where |
| 1032 | + D: SolverDelegate<Interner = I>, |
| 1033 | + I: Interner, |
| 1034 | +{ |
| 1035 | + type Result = ControlFlow<Result<(), NoSolution>>; |
| 1036 | + |
| 1037 | + fn visit_binder<T: TypeFoldable<I>>(&mut self, t: &ty::Binder<I, T>) -> Self::Result { |
| 1038 | + self.ecx.enter_forall(t.clone(), |ecx, v| { |
| 1039 | + v.visit_with(&mut FindParamInClause { ecx, param_env: self.param_env }) |
| 1040 | + }) |
| 1041 | + } |
| 1042 | + |
| 1043 | + fn visit_ty(&mut self, ty: I::Ty) -> Self::Result { |
| 1044 | + let Ok(ty) = self.ecx.structurally_normalize_ty(self.param_env, ty) else { |
| 1045 | + return ControlFlow::Break(Err(NoSolution)); |
| 1046 | + }; |
| 1047 | + |
| 1048 | + if let ty::Placeholder(_) = ty.kind() { |
| 1049 | + ControlFlow::Break(Ok(())) |
| 1050 | + } else { |
| 1051 | + ty.super_visit_with(self) |
| 1052 | + } |
| 1053 | + } |
| 1054 | + |
| 1055 | + fn visit_const(&mut self, ct: I::Const) -> Self::Result { |
| 1056 | + let Ok(ct) = self.ecx.structurally_normalize_const(self.param_env, ct) else { |
| 1057 | + return ControlFlow::Break(Err(NoSolution)); |
| 1058 | + }; |
| 1059 | + |
| 1060 | + if let ty::ConstKind::Placeholder(_) = ct.kind() { |
| 1061 | + ControlFlow::Break(Ok(())) |
| 1062 | + } else { |
| 1063 | + ct.super_visit_with(self) |
| 1064 | + } |
| 1065 | + } |
| 1066 | + |
| 1067 | + fn visit_region(&mut self, r: I::Region) -> Self::Result { |
| 1068 | + match self.ecx.eager_resolve_region(r).kind() { |
| 1069 | + ty::ReStatic | ty::ReError(_) => ControlFlow::Continue(()), |
| 1070 | + ty::ReVar(_) | ty::RePlaceholder(_) => ControlFlow::Break(Ok(())), |
| 1071 | + ty::ReErased | ty::ReEarlyParam(_) | ty::ReLateParam(_) | ty::ReBound(..) => { |
| 1072 | + unreachable!() |
| 1073 | + } |
| 1074 | + } |
| 1075 | + } |
946 | 1076 | } |
0 commit comments