rustc_trait_selection/solve/
delegate.rs1use std::ops::Deref;
2
3use rustc_data_structures::fx::FxHashSet;
4use rustc_hir::LangItem;
5use rustc_hir::def_id::{CRATE_DEF_ID, DefId};
6use rustc_infer::infer::canonical::query_response::make_query_region_constraints;
7use rustc_infer::infer::canonical::{
8 Canonical, CanonicalExt as _, CanonicalQueryInput, CanonicalVarKind, CanonicalVarValues,
9};
10use rustc_infer::infer::{InferCtxt, RegionVariableOrigin, SubregionOrigin, TyCtxtInferExt};
11use rustc_infer::traits::solve::Goal;
12use rustc_middle::traits::query::NoSolution;
13use rustc_middle::traits::solve::Certainty;
14use rustc_middle::ty::{
15 self, SizedTraitKind, Ty, TyCtxt, TypeFlags, TypeFoldable, TypeVisitableExt as _, TypingMode,
16};
17use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span};
18
19use crate::traits::{EvaluateConstErr, ObligationCause, specialization_graph};
20
21#[repr(transparent)]
22pub struct SolverDelegate<'tcx>(InferCtxt<'tcx>);
23
24impl<'a, 'tcx> From<&'a InferCtxt<'tcx>> for &'a SolverDelegate<'tcx> {
25 fn from(infcx: &'a InferCtxt<'tcx>) -> Self {
26 unsafe { std::mem::transmute(infcx) }
28 }
29}
30
31impl<'tcx> Deref for SolverDelegate<'tcx> {
32 type Target = InferCtxt<'tcx>;
33
34 fn deref(&self) -> &Self::Target {
35 &self.0
36 }
37}
38
39impl<'tcx> rustc_next_trait_solver::delegate::SolverDelegate for SolverDelegate<'tcx> {
40 type Infcx = InferCtxt<'tcx>;
41 type Interner = TyCtxt<'tcx>;
42
43 fn cx(&self) -> TyCtxt<'tcx> {
44 self.0.tcx
45 }
46
47 fn build_with_canonical<V>(
48 interner: TyCtxt<'tcx>,
49 canonical: &CanonicalQueryInput<'tcx, V>,
50 ) -> (Self, V, CanonicalVarValues<'tcx>)
51 where
52 V: TypeFoldable<TyCtxt<'tcx>>,
53 {
54 let (infcx, value, vars) = interner
55 .infer_ctxt()
56 .with_next_trait_solver(true)
57 .build_with_canonical(DUMMY_SP, canonical);
58 (SolverDelegate(infcx), value, vars)
59 }
60
61 fn compute_goal_fast_path(
62 &self,
63 goal: Goal<'tcx, ty::Predicate<'tcx>>,
64 span: Span,
65 ) -> Option<Certainty> {
66 if let Some(trait_pred) = goal.predicate.as_trait_clause() {
67 if self.shallow_resolve(trait_pred.self_ty().skip_binder()).is_ty_var()
68 && self.inner.borrow_mut().opaque_types().is_empty()
73 {
74 return Some(Certainty::AMBIGUOUS);
75 }
76
77 if trait_pred.polarity() == ty::PredicatePolarity::Positive {
78 match self.0.tcx.as_lang_item(trait_pred.def_id()) {
79 Some(LangItem::Sized)
80 if self
81 .resolve_vars_if_possible(trait_pred.self_ty().skip_binder())
82 .has_trivial_sizedness(self.0.tcx, SizedTraitKind::Sized) =>
83 {
84 return Some(Certainty::Yes);
85 }
86 Some(LangItem::MetaSized)
87 if self
88 .resolve_vars_if_possible(trait_pred.self_ty().skip_binder())
89 .has_trivial_sizedness(self.0.tcx, SizedTraitKind::MetaSized) =>
90 {
91 return Some(Certainty::Yes);
92 }
93 Some(LangItem::Copy | LangItem::Clone) => {
94 let self_ty =
95 self.resolve_vars_if_possible(trait_pred.self_ty().skip_binder());
96 if !self_ty
102 .has_type_flags(TypeFlags::HAS_FREE_REGIONS | TypeFlags::HAS_INFER)
103 && self_ty.is_trivially_pure_clone_copy()
104 {
105 return Some(Certainty::Yes);
106 }
107 }
108 _ => {}
109 }
110 }
111 }
112
113 let pred = goal.predicate.kind();
114 match pred.no_bound_vars()? {
115 ty::PredicateKind::DynCompatible(def_id) if self.0.tcx.is_dyn_compatible(def_id) => {
116 Some(Certainty::Yes)
117 }
118 ty::PredicateKind::Clause(ty::ClauseKind::RegionOutlives(outlives)) => {
119 self.0.sub_regions(
120 SubregionOrigin::RelateRegionParamBound(span, None),
121 outlives.1,
122 outlives.0,
123 );
124 Some(Certainty::Yes)
125 }
126 ty::PredicateKind::Clause(ty::ClauseKind::TypeOutlives(outlives)) => {
127 self.0.register_type_outlives_constraint(
128 outlives.0,
129 outlives.1,
130 &ObligationCause::dummy_with_span(span),
131 );
132
133 Some(Certainty::Yes)
134 }
135 ty::PredicateKind::Subtype(ty::SubtypePredicate { a, b, .. })
136 | ty::PredicateKind::Coerce(ty::CoercePredicate { a, b }) => {
137 if self.shallow_resolve(a).is_ty_var() && self.shallow_resolve(b).is_ty_var() {
138 Some(Certainty::AMBIGUOUS)
142 } else {
143 None
144 }
145 }
146 ty::PredicateKind::Clause(ty::ClauseKind::WellFormed(arg)) => {
147 let arg = self.shallow_resolve_term(arg);
148 if arg.is_trivially_wf(self.tcx) {
149 Some(Certainty::Yes)
150 } else if arg.is_infer() {
151 Some(Certainty::AMBIGUOUS)
152 } else {
153 None
154 }
155 }
156 _ => None,
157 }
158 }
159
160 fn fresh_var_for_kind_with_span(
161 &self,
162 arg: ty::GenericArg<'tcx>,
163 span: Span,
164 ) -> ty::GenericArg<'tcx> {
165 match arg.kind() {
166 ty::GenericArgKind::Lifetime(_) => {
167 self.next_region_var(RegionVariableOrigin::Misc(span)).into()
168 }
169 ty::GenericArgKind::Type(_) => self.next_ty_var(span).into(),
170 ty::GenericArgKind::Const(_) => self.next_const_var(span).into(),
171 }
172 }
173
174 fn leak_check(&self, max_input_universe: ty::UniverseIndex) -> Result<(), NoSolution> {
175 self.0.leak_check(max_input_universe, None).map_err(|_| NoSolution)
176 }
177
178 fn evaluate_const(
179 &self,
180 param_env: ty::ParamEnv<'tcx>,
181 uv: ty::UnevaluatedConst<'tcx>,
182 ) -> Option<ty::Const<'tcx>> {
183 let ct = ty::Const::new_unevaluated(self.tcx, uv);
184
185 match crate::traits::try_evaluate_const(&self.0, ct, param_env) {
186 Ok(ct) => Some(ct),
187 Err(EvaluateConstErr::EvaluationFailure(e)) => Some(ty::Const::new_error(self.tcx, e)),
188 Err(
189 EvaluateConstErr::InvalidConstParamTy(_) | EvaluateConstErr::HasGenericsOrInfers,
190 ) => None,
191 }
192 }
193
194 fn well_formed_goals(
195 &self,
196 param_env: ty::ParamEnv<'tcx>,
197 term: ty::Term<'tcx>,
198 ) -> Option<Vec<Goal<'tcx, ty::Predicate<'tcx>>>> {
199 crate::traits::wf::unnormalized_obligations(
200 &self.0,
201 param_env,
202 term,
203 DUMMY_SP,
204 CRATE_DEF_ID,
205 )
206 .map(|obligations| obligations.into_iter().map(|obligation| obligation.as_goal()).collect())
207 }
208
209 fn make_deduplicated_outlives_constraints(
210 &self,
211 ) -> Vec<ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>> {
212 let region_obligations = self.0.inner.borrow().region_obligations().to_owned();
215 let region_constraints = self.0.with_region_constraints(|region_constraints| {
216 make_query_region_constraints(
217 self.tcx,
218 region_obligations
219 .iter()
220 .map(|r_o| (r_o.sup_type, r_o.sub_region, r_o.origin.to_constraint_category())),
221 region_constraints,
222 )
223 });
224
225 let mut seen = FxHashSet::default();
226 region_constraints
227 .outlives
228 .into_iter()
229 .filter(|&(outlives, _)| seen.insert(outlives))
230 .map(|(outlives, _)| outlives)
231 .collect()
232 }
233
234 fn instantiate_canonical<V>(
235 &self,
236 canonical: Canonical<'tcx, V>,
237 values: CanonicalVarValues<'tcx>,
238 ) -> V
239 where
240 V: TypeFoldable<TyCtxt<'tcx>>,
241 {
242 canonical.instantiate(self.tcx, &values)
243 }
244
245 fn instantiate_canonical_var_with_infer(
246 &self,
247 kind: CanonicalVarKind<'tcx>,
248 span: Span,
249 universe_map: impl Fn(ty::UniverseIndex) -> ty::UniverseIndex,
250 ) -> ty::GenericArg<'tcx> {
251 self.0.instantiate_canonical_var(span, kind, universe_map)
252 }
253
254 fn add_item_bounds_for_hidden_type(
255 &self,
256 def_id: DefId,
257 args: ty::GenericArgsRef<'tcx>,
258 param_env: ty::ParamEnv<'tcx>,
259 hidden_ty: Ty<'tcx>,
260 goals: &mut Vec<Goal<'tcx, ty::Predicate<'tcx>>>,
261 ) {
262 self.0.add_item_bounds_for_hidden_type(def_id, args, param_env, hidden_ty, goals);
263 }
264
265 fn fetch_eligible_assoc_item(
266 &self,
267 goal_trait_ref: ty::TraitRef<'tcx>,
268 trait_assoc_def_id: DefId,
269 impl_def_id: DefId,
270 ) -> Result<Option<DefId>, ErrorGuaranteed> {
271 let node_item = specialization_graph::assoc_def(self.tcx, impl_def_id, trait_assoc_def_id)?;
272
273 let eligible = if node_item.is_final() {
274 true
276 } else {
277 match self.typing_mode() {
282 TypingMode::Coherence
283 | TypingMode::Analysis { .. }
284 | TypingMode::Borrowck { .. }
285 | TypingMode::PostBorrowckAnalysis { .. } => false,
286 TypingMode::PostAnalysis => {
287 let poly_trait_ref = self.resolve_vars_if_possible(goal_trait_ref);
288 !poly_trait_ref.still_further_specializable()
289 }
290 }
291 };
292
293 if eligible { Ok(Some(node_item.item.def_id)) } else { Ok(None) }
295 }
296
297 fn is_transmutable(
300 &self,
301 dst: Ty<'tcx>,
302 src: Ty<'tcx>,
303 assume: ty::Const<'tcx>,
304 ) -> Result<Certainty, NoSolution> {
305 let (dst, src) = self.tcx.erase_regions((dst, src));
308
309 let Some(assume) = rustc_transmute::Assume::from_const(self.tcx, assume) else {
310 return Err(NoSolution);
311 };
312
313 match rustc_transmute::TransmuteTypeEnv::new(self.0.tcx)
315 .is_transmutable(rustc_transmute::Types { src, dst }, assume)
316 {
317 rustc_transmute::Answer::Yes => Ok(Certainty::Yes),
318 rustc_transmute::Answer::No(_) | rustc_transmute::Answer::If(_) => Err(NoSolution),
319 }
320 }
321}