1 //! A nice interface for working with the infcx. The basic idea is to
2 //! do `infcx.at(cause, param_env)`, which sets the "cause" of the
3 //! operation as well as the surrounding parameter environment. Then
4 //! you can do something like `.sub(a, b)` or `.eq(a, b)` to create a
5 //! subtype or equality relationship respectively. The first argument
6 //! is always the "expected" output from the POV of diagnostics.
9 //! ```ignore (fragment)
10 //! infcx.at(cause, param_env).sub(a, b)
11 //! // requires that `a <: b`, with `a` considered the "expected" type
13 //! infcx.at(cause, param_env).sup(a, b)
14 //! // requires that `b <: a`, with `a` considered the "expected" type
16 //! infcx.at(cause, param_env).eq(a, b)
17 //! // requires that `a == b`, with `a` considered the "expected" type
19 //! For finer-grained control, you can also do use `trace`:
20 //! ```ignore (fragment)
21 //! infcx.at(...).trace(a, b).sub(&c, &d)
23 //! This will set `a` and `b` as the "root" values for
24 //! error-reporting, but actually operate on `c` and `d`. This is
25 //! sometimes useful when the types of `c` and `d` are not traceable
26 //! things. (That system should probably be refactored.)
30 use rustc_middle::ty::relate::{Relate, TypeRelation};
31 use rustc_middle::ty::{Const, ImplSubject};
33 pub struct At<'a, 'tcx> {
34 pub infcx: &'a InferCtxt<'a, 'tcx>,
35 pub cause: &'a ObligationCause<'tcx>,
36 pub param_env: ty::ParamEnv<'tcx>,
37 /// Whether we should define opaque types
38 /// or just treat them opaquely.
39 /// Currently only used to prevent predicate
40 /// matching from matching anything against opaque
42 pub define_opaque_types: bool,
45 pub struct Trace<'a, 'tcx> {
48 trace: TypeTrace<'tcx>,
51 impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
55 cause: &'a ObligationCause<'tcx>,
56 param_env: ty::ParamEnv<'tcx>,
58 At { infcx: self, cause, param_env, define_opaque_types: true }
61 /// Forks the inference context, creating a new inference context with the same inference
62 /// variables in the same state. This can be used to "branch off" many tests from the same
63 /// common state. Used in coherence.
64 pub fn fork(&self) -> Self {
67 defining_use_anchor: self.defining_use_anchor,
68 considering_regions: self.considering_regions,
69 in_progress_typeck_results: self.in_progress_typeck_results,
70 inner: self.inner.clone(),
71 skip_leak_check: self.skip_leak_check.clone(),
72 lexical_region_resolutions: self.lexical_region_resolutions.clone(),
73 selection_cache: self.selection_cache.clone(),
74 evaluation_cache: self.evaluation_cache.clone(),
75 reported_trait_errors: self.reported_trait_errors.clone(),
76 reported_closure_mismatch: self.reported_closure_mismatch.clone(),
77 tainted_by_errors_flag: self.tainted_by_errors_flag.clone(),
78 err_count_on_creation: self.err_count_on_creation,
79 in_snapshot: self.in_snapshot.clone(),
80 universe: self.universe.clone(),
85 pub trait ToTrace<'tcx>: Relate<'tcx> + Copy {
88 cause: &ObligationCause<'tcx>,
95 impl<'a, 'tcx> At<'a, 'tcx> {
96 pub fn define_opaque_types(self, define_opaque_types: bool) -> Self {
97 Self { define_opaque_types, ..self }
100 /// Hacky routine for equating two impl headers in coherence.
101 pub fn eq_impl_headers(
103 expected: &ty::ImplHeader<'tcx>,
104 actual: &ty::ImplHeader<'tcx>,
105 ) -> InferResult<'tcx, ()> {
106 debug!("eq_impl_header({:?} = {:?})", expected, actual);
107 match (expected.trait_ref, actual.trait_ref) {
108 (Some(a_ref), Some(b_ref)) => self.eq(a_ref, b_ref),
109 (None, None) => self.eq(expected.self_ty, actual.self_ty),
110 _ => bug!("mk_eq_impl_headers given mismatched impl kinds"),
114 /// Makes `a <: b`, where `a` may or may not be expected.
116 /// See [`At::trace_exp`] and [`Trace::sub`] for a version of
117 /// this method that only requires `T: Relate<'tcx>`
118 pub fn sub_exp<T>(self, a_is_expected: bool, a: T, b: T) -> InferResult<'tcx, ()>
122 self.trace_exp(a_is_expected, a, b).sub(a, b)
125 /// Makes `actual <: expected`. For example, if type-checking a
126 /// call like `foo(x)`, where `foo: fn(i32)`, you might have
127 /// `sup(i32, x)`, since the "expected" type is the type that
128 /// appears in the signature.
130 /// See [`At::trace`] and [`Trace::sub`] for a version of
131 /// this method that only requires `T: Relate<'tcx>`
132 pub fn sup<T>(self, expected: T, actual: T) -> InferResult<'tcx, ()>
136 self.sub_exp(false, actual, expected)
139 /// Makes `expected <: actual`.
141 /// See [`At::trace`] and [`Trace::sub`] for a version of
142 /// this method that only requires `T: Relate<'tcx>`
143 pub fn sub<T>(self, expected: T, actual: T) -> InferResult<'tcx, ()>
147 self.sub_exp(true, expected, actual)
150 /// Makes `expected <: actual`.
152 /// See [`At::trace_exp`] and [`Trace::eq`] for a version of
153 /// this method that only requires `T: Relate<'tcx>`
154 pub fn eq_exp<T>(self, a_is_expected: bool, a: T, b: T) -> InferResult<'tcx, ()>
158 self.trace_exp(a_is_expected, a, b).eq(a, b)
161 /// Makes `expected <: actual`.
163 /// See [`At::trace`] and [`Trace::eq`] for a version of
164 /// this method that only requires `T: Relate<'tcx>`
165 pub fn eq<T>(self, expected: T, actual: T) -> InferResult<'tcx, ()>
169 self.trace(expected, actual).eq(expected, actual)
172 pub fn relate<T>(self, expected: T, variance: ty::Variance, actual: T) -> InferResult<'tcx, ()>
177 ty::Variance::Covariant => self.sub(expected, actual),
178 ty::Variance::Invariant => self.eq(expected, actual),
179 ty::Variance::Contravariant => self.sup(expected, actual),
181 // We could make this make sense but it's not readily
182 // exposed and I don't feel like dealing with it. Note
183 // that bivariance in general does a bit more than just
184 // *nothing*, it checks that the types are the same
185 // "modulo variance" basically.
186 ty::Variance::Bivariant => panic!("Bivariant given to `relate()`"),
190 /// Computes the least-upper-bound, or mutual supertype, of two
191 /// values. The order of the arguments doesn't matter, but since
192 /// this can result in an error (e.g., if asked to compute LUB of
193 /// u32 and i32), it is meaningful to call one of them the
196 /// See [`At::trace`] and [`Trace::lub`] for a version of
197 /// this method that only requires `T: Relate<'tcx>`
198 pub fn lub<T>(self, expected: T, actual: T) -> InferResult<'tcx, T>
202 self.trace(expected, actual).lub(expected, actual)
205 /// Computes the greatest-lower-bound, or mutual subtype, of two
206 /// values. As with `lub` order doesn't matter, except for error
209 /// See [`At::trace`] and [`Trace::glb`] for a version of
210 /// this method that only requires `T: Relate<'tcx>`
211 pub fn glb<T>(self, expected: T, actual: T) -> InferResult<'tcx, T>
215 self.trace(expected, actual).glb(expected, actual)
218 /// Sets the "trace" values that will be used for
219 /// error-reporting, but doesn't actually perform any operation
220 /// yet (this is useful when you want to set the trace using
221 /// distinct values from those you wish to operate upon).
222 pub fn trace<T>(self, expected: T, actual: T) -> Trace<'a, 'tcx>
226 self.trace_exp(true, expected, actual)
229 /// Like `trace`, but the expected value is determined by the
230 /// boolean argument (if true, then the first argument `a` is the
231 /// "expected" value).
232 pub fn trace_exp<T>(self, a_is_expected: bool, a: T, b: T) -> Trace<'a, 'tcx>
236 let trace = ToTrace::to_trace(self.infcx.tcx, self.cause, a_is_expected, a, b);
237 Trace { at: self, trace, a_is_expected }
241 impl<'a, 'tcx> Trace<'a, 'tcx> {
242 /// Makes `a <: b` where `a` may or may not be expected (if
243 /// `a_is_expected` is true, then `a` is expected).
244 #[instrument(skip(self), level = "debug")]
245 pub fn sub<T>(self, a: T, b: T) -> InferResult<'tcx, ()>
249 let Trace { at, trace, a_is_expected } = self;
250 at.infcx.commit_if_ok(|_| {
251 let mut fields = at.infcx.combine_fields(trace, at.param_env, at.define_opaque_types);
255 .map(move |_| InferOk { value: (), obligations: fields.obligations })
259 /// Makes `a == b`; the expectation is set by the call to
261 #[instrument(skip(self), level = "debug")]
262 pub fn eq<T>(self, a: T, b: T) -> InferResult<'tcx, ()>
266 let Trace { at, trace, a_is_expected } = self;
267 at.infcx.commit_if_ok(|_| {
268 let mut fields = at.infcx.combine_fields(trace, at.param_env, at.define_opaque_types);
270 .equate(a_is_expected)
272 .map(move |_| InferOk { value: (), obligations: fields.obligations })
276 #[instrument(skip(self), level = "debug")]
277 pub fn lub<T>(self, a: T, b: T) -> InferResult<'tcx, T>
281 let Trace { at, trace, a_is_expected } = self;
282 at.infcx.commit_if_ok(|_| {
283 let mut fields = at.infcx.combine_fields(trace, at.param_env, at.define_opaque_types);
287 .map(move |t| InferOk { value: t, obligations: fields.obligations })
291 #[instrument(skip(self), level = "debug")]
292 pub fn glb<T>(self, a: T, b: T) -> InferResult<'tcx, T>
296 let Trace { at, trace, a_is_expected } = self;
297 at.infcx.commit_if_ok(|_| {
298 let mut fields = at.infcx.combine_fields(trace, at.param_env, at.define_opaque_types);
302 .map(move |t| InferOk { value: t, obligations: fields.obligations })
307 impl<'tcx> ToTrace<'tcx> for ImplSubject<'tcx> {
310 cause: &ObligationCause<'tcx>,
314 ) -> TypeTrace<'tcx> {
316 (ImplSubject::Trait(trait_ref_a), ImplSubject::Trait(trait_ref_b)) => {
317 ToTrace::to_trace(tcx, cause, a_is_expected, trait_ref_a, trait_ref_b)
319 (ImplSubject::Inherent(ty_a), ImplSubject::Inherent(ty_b)) => {
320 ToTrace::to_trace(tcx, cause, a_is_expected, ty_a, ty_b)
322 (ImplSubject::Trait(_), ImplSubject::Inherent(_))
323 | (ImplSubject::Inherent(_), ImplSubject::Trait(_)) => {
324 bug!("can not trace TraitRef and Ty");
330 impl<'tcx> ToTrace<'tcx> for Ty<'tcx> {
333 cause: &ObligationCause<'tcx>,
337 ) -> TypeTrace<'tcx> {
339 cause: cause.clone(),
340 values: Terms(ExpectedFound::new(a_is_expected, a.into(), b.into())),
345 impl<'tcx> ToTrace<'tcx> for ty::Region<'tcx> {
348 cause: &ObligationCause<'tcx>,
352 ) -> TypeTrace<'tcx> {
353 TypeTrace { cause: cause.clone(), values: Regions(ExpectedFound::new(a_is_expected, a, b)) }
357 impl<'tcx> ToTrace<'tcx> for Const<'tcx> {
360 cause: &ObligationCause<'tcx>,
364 ) -> TypeTrace<'tcx> {
366 cause: cause.clone(),
367 values: Terms(ExpectedFound::new(a_is_expected, a.into(), b.into())),
372 impl<'tcx> ToTrace<'tcx> for ty::Term<'tcx> {
375 cause: &ObligationCause<'tcx>,
379 ) -> TypeTrace<'tcx> {
380 TypeTrace { cause: cause.clone(), values: Terms(ExpectedFound::new(a_is_expected, a, b)) }
384 impl<'tcx> ToTrace<'tcx> for ty::TraitRef<'tcx> {
387 cause: &ObligationCause<'tcx>,
391 ) -> TypeTrace<'tcx> {
393 cause: cause.clone(),
394 values: TraitRefs(ExpectedFound::new(a_is_expected, a, b)),
399 impl<'tcx> ToTrace<'tcx> for ty::PolyTraitRef<'tcx> {
402 cause: &ObligationCause<'tcx>,
406 ) -> TypeTrace<'tcx> {
408 cause: cause.clone(),
409 values: PolyTraitRefs(ExpectedFound::new(a_is_expected, a, b)),
414 impl<'tcx> ToTrace<'tcx> for ty::ProjectionTy<'tcx> {
417 cause: &ObligationCause<'tcx>,
421 ) -> TypeTrace<'tcx> {
422 let a_ty = tcx.mk_projection(a.item_def_id, a.substs);
423 let b_ty = tcx.mk_projection(b.item_def_id, b.substs);
425 cause: cause.clone(),
426 values: Terms(ExpectedFound::new(a_is_expected, a_ty.into(), b_ty.into())),