1 use std::cell::RefCell;
4 use super::TraitEngine;
5 use super::{ChalkFulfillmentContext, FulfillmentContext};
6 use crate::traits::NormalizeExt;
7 use rustc_data_structures::fx::FxIndexSet;
8 use rustc_hir::def_id::{DefId, LocalDefId};
9 use rustc_infer::infer::at::ToTrace;
10 use rustc_infer::infer::canonical::{
11 Canonical, CanonicalVarValues, CanonicalizedQueryResponse, QueryResponse,
13 use rustc_infer::infer::{InferCtxt, InferOk};
14 use rustc_infer::traits::query::Fallible;
15 use rustc_infer::traits::{
16 FulfillmentError, Obligation, ObligationCause, PredicateObligation, TraitEngineExt as _,
18 use rustc_middle::arena::ArenaAllocatable;
19 use rustc_middle::ty::error::TypeError;
20 use rustc_middle::ty::ToPredicate;
21 use rustc_middle::ty::TypeFoldable;
22 use rustc_middle::ty::{self, Ty, TyCtxt};
25 pub trait TraitEngineExt<'tcx> {
26 fn new(tcx: TyCtxt<'tcx>) -> Box<Self>;
27 fn new_in_snapshot(tcx: TyCtxt<'tcx>) -> Box<Self>;
30 impl<'tcx> TraitEngineExt<'tcx> for dyn TraitEngine<'tcx> {
31 fn new(tcx: TyCtxt<'tcx>) -> Box<Self> {
32 if tcx.sess.opts.unstable_opts.chalk {
33 Box::new(ChalkFulfillmentContext::new())
35 Box::new(FulfillmentContext::new())
39 fn new_in_snapshot(tcx: TyCtxt<'tcx>) -> Box<Self> {
40 if tcx.sess.opts.unstable_opts.chalk {
41 Box::new(ChalkFulfillmentContext::new_in_snapshot())
43 Box::new(FulfillmentContext::new_in_snapshot())
48 /// Used if you want to have pleasant experience when dealing
49 /// with obligations outside of hir or mir typeck.
50 pub struct ObligationCtxt<'a, 'tcx> {
51 pub infcx: &'a InferCtxt<'tcx>,
52 engine: RefCell<Box<dyn TraitEngine<'tcx>>>,
55 impl<'a, 'tcx> ObligationCtxt<'a, 'tcx> {
56 pub fn new(infcx: &'a InferCtxt<'tcx>) -> Self {
57 Self { infcx, engine: RefCell::new(<dyn TraitEngine<'_>>::new(infcx.tcx)) }
60 pub fn new_in_snapshot(infcx: &'a InferCtxt<'tcx>) -> Self {
61 Self { infcx, engine: RefCell::new(<dyn TraitEngine<'_>>::new_in_snapshot(infcx.tcx)) }
64 pub fn register_obligation(&self, obligation: PredicateObligation<'tcx>) {
65 self.engine.borrow_mut().register_predicate_obligation(self.infcx, obligation);
68 pub fn register_obligations(
70 obligations: impl IntoIterator<Item = PredicateObligation<'tcx>>,
72 // Can't use `register_predicate_obligations` because the iterator
73 // may also use this `ObligationCtxt`.
74 for obligation in obligations {
75 self.engine.borrow_mut().register_predicate_obligation(self.infcx, obligation)
79 pub fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
80 let InferOk { value, obligations } = infer_ok;
81 self.engine.borrow_mut().register_predicate_obligations(self.infcx, obligations);
85 /// Requires that `ty` must implement the trait with `def_id` in
86 /// the given environment. This trait must not have any type
87 /// parameters (except for `Self`).
88 pub fn register_bound(
90 cause: ObligationCause<'tcx>,
91 param_env: ty::ParamEnv<'tcx>,
95 let tcx = self.infcx.tcx;
96 let trait_ref = tcx.mk_trait_ref(def_id, [ty]);
97 self.register_obligation(Obligation {
101 predicate: ty::Binder::dummy(trait_ref).without_const().to_predicate(tcx),
105 pub fn normalize<T: TypeFoldable<'tcx>>(
107 cause: &ObligationCause<'tcx>,
108 param_env: ty::ParamEnv<'tcx>,
111 let infer_ok = self.infcx.at(&cause, param_env).normalize(value);
112 self.register_infer_ok_obligations(infer_ok)
115 /// Makes `expected <: actual`.
118 cause: &ObligationCause<'tcx>,
119 param_env: ty::ParamEnv<'tcx>,
123 ) -> Result<(), TypeError<'tcx>>
128 .at(cause, param_env)
129 .eq_exp(a_is_expected, a, b)
130 .map(|infer_ok| self.register_infer_ok_obligations(infer_ok))
133 pub fn eq<T: ToTrace<'tcx>>(
135 cause: &ObligationCause<'tcx>,
136 param_env: ty::ParamEnv<'tcx>,
139 ) -> Result<(), TypeError<'tcx>> {
141 .at(cause, param_env)
142 .eq(expected, actual)
143 .map(|infer_ok| self.register_infer_ok_obligations(infer_ok))
146 /// Checks whether `expected` is a subtype of `actual`: `expected <: actual`.
147 pub fn sub<T: ToTrace<'tcx>>(
149 cause: &ObligationCause<'tcx>,
150 param_env: ty::ParamEnv<'tcx>,
153 ) -> Result<(), TypeError<'tcx>> {
155 .at(cause, param_env)
156 .sup(expected, actual)
157 .map(|infer_ok| self.register_infer_ok_obligations(infer_ok))
160 /// Checks whether `expected` is a supertype of `actual`: `expected :> actual`.
161 pub fn sup<T: ToTrace<'tcx>>(
163 cause: &ObligationCause<'tcx>,
164 param_env: ty::ParamEnv<'tcx>,
167 ) -> Result<(), TypeError<'tcx>> {
169 .at(cause, param_env)
170 .sup(expected, actual)
171 .map(|infer_ok| self.register_infer_ok_obligations(infer_ok))
174 pub fn select_where_possible(&self) -> Vec<FulfillmentError<'tcx>> {
175 self.engine.borrow_mut().select_where_possible(self.infcx)
178 pub fn select_all_or_error(&self) -> Vec<FulfillmentError<'tcx>> {
179 self.engine.borrow_mut().select_all_or_error(self.infcx)
182 pub fn assumed_wf_types(
184 param_env: ty::ParamEnv<'tcx>,
187 ) -> FxIndexSet<Ty<'tcx>> {
188 let tcx = self.infcx.tcx;
189 let assumed_wf_types = tcx.assumed_wf_types(def_id);
190 let mut implied_bounds = FxIndexSet::default();
191 let hir_id = tcx.hir().local_def_id_to_hir_id(def_id);
192 let cause = ObligationCause::misc(span, hir_id);
193 for ty in assumed_wf_types {
194 // FIXME(@lcnr): rustc currently does not check wf for types
195 // pre-normalization, meaning that implied bounds are sometimes
196 // incorrect. See #100910 for more details.
198 // Not adding the unnormalized types here mostly fixes that, except
199 // that there are projections which are still ambiguous in the item definition
200 // but do normalize successfully when using the item, see #98543.
202 // Anyways, I will hopefully soon change implied bounds to make all of this
203 // sound and then uncomment this line again.
205 // implied_bounds.insert(ty);
206 let normalized = self.normalize(&cause, param_env, ty);
207 implied_bounds.insert(normalized);
212 pub fn make_canonicalized_query_response<T>(
214 inference_vars: CanonicalVarValues<'tcx>,
216 ) -> Fallible<CanonicalizedQueryResponse<'tcx, T>>
218 T: Debug + TypeFoldable<'tcx>,
219 Canonical<'tcx, QueryResponse<'tcx, T>>: ArenaAllocatable<'tcx>,
221 self.infcx.make_canonicalized_query_response(
224 &mut **self.engine.borrow_mut(),