rustc_trait_selection/solve/
delegate.rs

1use 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        // SAFETY: `repr(transparent)`
27        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                // We don't do this fast path when opaques are defined since we may
69                // eventually use opaques to incompletely guide inference via ty var
70                // self types.
71                // FIXME: Properly consider opaques here.
72                && 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                        // Unlike `Sized` traits, which always prefer the built-in impl,
97                        // `Copy`/`Clone` may be shadowed by a param-env candidate which
98                        // could force a lifetime error or guide inference. While that's
99                        // not generally desirable, it is observable, so for now let's
100                        // ignore this fast path for types that have regions or infer.
101                        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                    // FIXME: We also need to register a subtype relation between these vars
139                    // when those are added, and if they aren't in the same sub root then
140                    // we should mark this goal as `has_changed`.
141                    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        // Cannot use `take_registered_region_obligations` as we may compute the response
213        // inside of a `probe` whenever we have multiple choices inside of the solver.
214        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            // Non-specializable items are always projectable.
275            true
276        } else {
277            // Only reveal a specializable default if we're past type-checking
278            // and the obligation is monomorphic, otherwise passes such as
279            // transmute checking and polymorphic MIR optimizations could
280            // get a result which isn't correct for all monomorphizations.
281            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        // FIXME: Check for defaultness here may cause diagnostics problems.
294        if eligible { Ok(Some(node_item.item.def_id)) } else { Ok(None) }
295    }
296
297    // FIXME: This actually should destructure the `Result` we get from transmutability and
298    // register candidates. We probably need to register >1 since we may have an OR of ANDs.
299    fn is_transmutable(
300        &self,
301        dst: Ty<'tcx>,
302        src: Ty<'tcx>,
303        assume: ty::Const<'tcx>,
304    ) -> Result<Certainty, NoSolution> {
305        // Erase regions because we compute layouts in `rustc_transmute`,
306        // which will ICE for region vars.
307        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        // FIXME(transmutability): This really should be returning nested goals for `Answer::If*`
314        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}
rustc_trait_selection/solve/delegate.rs

rustc_trait_selection/solve/
delegate.rs
