1 use crate::traits::query::evaluate_obligation::InferCtxtExt as _;
2 use crate::traits::query::outlives_bounds::InferCtxtExt as _;
3 use crate::traits::{self, TraitEngine, TraitEngineExt};
6 use rustc_hir::def_id::DefId;
7 use rustc_hir::lang_items::LangItem;
8 use rustc_infer::infer::outlives::env::OutlivesEnvironment;
9 use rustc_infer::traits::ObligationCause;
10 use rustc_middle::arena::ArenaAllocatable;
11 use rustc_middle::infer::canonical::{Canonical, CanonicalizedQueryResponse, QueryResponse};
12 use rustc_middle::traits::query::Fallible;
13 use rustc_middle::ty::subst::SubstsRef;
14 use rustc_middle::ty::ToPredicate;
15 use rustc_middle::ty::WithConstness;
16 use rustc_middle::ty::{self, Ty, TypeFoldable};
17 use rustc_span::{Span, DUMMY_SP};
21 pub use rustc_infer::infer::*;
23 pub trait InferCtxtExt<'tcx> {
24 fn type_is_copy_modulo_regions(
26 param_env: ty::ParamEnv<'tcx>,
31 fn partially_normalize_associated_types_in<T>(
35 param_env: ty::ParamEnv<'tcx>,
39 T: TypeFoldable<'tcx>;
41 /// Check whether a `ty` implements given trait(trait_def_id).
44 /// - the def-id of the trait
46 /// - the *other* type parameters of the trait, excluding the self-type
47 /// - the parameter environment
48 fn type_implements_trait(
52 params: SubstsRef<'tcx>,
53 param_env: ty::ParamEnv<'tcx>,
54 ) -> traits::EvaluationResult;
56 impl<'cx, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'cx, 'tcx> {
57 fn type_is_copy_modulo_regions(
59 param_env: ty::ParamEnv<'tcx>,
63 let ty = self.resolve_vars_if_possible(ty);
65 if !(param_env, ty).needs_infer() {
66 return ty.is_copy_modulo_regions(self.tcx.at(span), param_env);
69 let copy_def_id = self.tcx.require_lang_item(LangItem::Copy, None);
71 // This can get called from typeck (by euv), and `moves_by_default`
72 // rightly refuses to work with inference variables, but
73 // moves_by_default has a cache, which we want to use in other
75 traits::type_known_to_meet_bound_modulo_regions(self, param_env, ty, copy_def_id, span)
78 /// Normalizes associated types in `value`, potentially returning
79 /// new obligations that must further be processed.
80 fn partially_normalize_associated_types_in<T>(
84 param_env: ty::ParamEnv<'tcx>,
88 T: TypeFoldable<'tcx>,
90 debug!("partially_normalize_associated_types_in(value={:?})", value);
91 let mut selcx = traits::SelectionContext::new(self);
92 let cause = ObligationCause::misc(span, body_id);
93 let traits::Normalized { value, obligations } =
94 traits::normalize(&mut selcx, param_env, cause, value);
96 "partially_normalize_associated_types_in: result={:?} predicates={:?}",
99 InferOk { value, obligations }
102 fn type_implements_trait(
106 params: SubstsRef<'tcx>,
107 param_env: ty::ParamEnv<'tcx>,
108 ) -> traits::EvaluationResult {
110 "type_implements_trait: trait_def_id={:?}, type={:?}, params={:?}, param_env={:?}",
111 trait_def_id, ty, params, param_env
115 ty::TraitRef { def_id: trait_def_id, substs: self.tcx.mk_substs_trait(ty, params) };
117 let obligation = traits::Obligation {
118 cause: traits::ObligationCause::dummy(),
121 predicate: trait_ref.without_const().to_predicate(self.tcx),
123 self.evaluate_obligation_no_overflow(&obligation)
127 pub trait InferCtxtBuilderExt<'tcx> {
128 fn enter_canonical_trait_query<K, R>(
130 canonical_key: &Canonical<'tcx, K>,
131 operation: impl FnOnce(&InferCtxt<'_, 'tcx>, &mut dyn TraitEngine<'tcx>, K) -> Fallible<R>,
132 ) -> Fallible<CanonicalizedQueryResponse<'tcx, R>>
134 K: TypeFoldable<'tcx>,
135 R: Debug + TypeFoldable<'tcx>,
136 Canonical<'tcx, QueryResponse<'tcx, R>>: ArenaAllocatable<'tcx>;
139 impl<'tcx> InferCtxtBuilderExt<'tcx> for InferCtxtBuilder<'tcx> {
140 /// The "main method" for a canonicalized trait query. Given the
141 /// canonical key `canonical_key`, this method will create a new
142 /// inference context, instantiate the key, and run your operation
143 /// `op`. The operation should yield up a result (of type `R`) as
144 /// well as a set of trait obligations that must be fully
145 /// satisfied. These obligations will be processed and the
146 /// canonical result created.
148 /// Returns `NoSolution` in the event of any error.
150 /// (It might be mildly nicer to implement this on `TyCtxt`, and
151 /// not `InferCtxtBuilder`, but that is a bit tricky right now.
152 /// In part because we would need a `for<'tcx>` sort of
153 /// bound for the closure and in part because it is convenient to
154 /// have `'tcx` be free on this function so that we can talk about
155 /// `K: TypeFoldable<'tcx>`.)
156 fn enter_canonical_trait_query<K, R>(
158 canonical_key: &Canonical<'tcx, K>,
159 operation: impl FnOnce(&InferCtxt<'_, 'tcx>, &mut dyn TraitEngine<'tcx>, K) -> Fallible<R>,
160 ) -> Fallible<CanonicalizedQueryResponse<'tcx, R>>
162 K: TypeFoldable<'tcx>,
163 R: Debug + TypeFoldable<'tcx>,
164 Canonical<'tcx, QueryResponse<'tcx, R>>: ArenaAllocatable<'tcx>,
166 self.enter_with_canonical(
169 |ref infcx, key, canonical_inference_vars| {
170 let mut fulfill_cx = <dyn TraitEngine<'_>>::new(infcx.tcx);
171 let value = operation(infcx, &mut *fulfill_cx, key)?;
172 infcx.make_canonicalized_query_response(
173 canonical_inference_vars,
182 pub trait OutlivesEnvironmentExt<'tcx> {
183 fn add_implied_bounds(
185 infcx: &InferCtxt<'a, 'tcx>,
186 fn_sig_tys: &[Ty<'tcx>],
192 impl<'tcx> OutlivesEnvironmentExt<'tcx> for OutlivesEnvironment<'tcx> {
193 /// This method adds "implied bounds" into the outlives environment.
194 /// Implied bounds are outlives relationships that we can deduce
195 /// on the basis that certain types must be well-formed -- these are
196 /// either the types that appear in the function signature or else
197 /// the input types to an impl. For example, if you have a function
201 /// fn foo<'a, 'b, T>(x: &'a &'b [T]) { }
204 /// we can assume in the caller's body that `'b: 'a` and that `T:
205 /// 'b` (and hence, transitively, that `T: 'a`). This method would
206 /// add those assumptions into the outlives-environment.
208 /// Tests: `src/test/ui/regions/regions-free-region-ordering-*.rs`
209 fn add_implied_bounds(
211 infcx: &InferCtxt<'a, 'tcx>,
212 fn_sig_tys: &[Ty<'tcx>],
216 debug!("add_implied_bounds()");
218 for &ty in fn_sig_tys {
219 let ty = infcx.resolve_vars_if_possible(ty);
220 debug!("add_implied_bounds: ty = {}", ty);
221 let implied_bounds = infcx.implied_outlives_bounds(self.param_env, body_id, ty, span);
222 self.add_outlives_bounds(Some(infcx), implied_bounds)