rustc_type_ir/
infer_ctxt.rs

1use derive_where::derive_where;
2#[cfg(feature = "nightly")]
3use rustc_macros::{Decodable_NoContext, Encodable_NoContext, HashStable_NoContext};
4use rustc_type_ir_macros::{TypeFoldable_Generic, TypeVisitable_Generic};
5
6use crate::fold::TypeFoldable;
7use crate::inherent::*;
8use crate::relate::RelateResult;
9use crate::relate::combine::PredicateEmittingRelation;
10use crate::{self as ty, Interner};
11
12/// The current typing mode of an inference context. We unfortunately have some
13/// slightly different typing rules depending on the current context. See the
14/// doc comment for each variant for how and why they are used.
15///
16/// In most cases you can get the correct typing mode automatically via:
17/// - `mir::Body::typing_mode`
18/// - `rustc_lint::LateContext::typing_mode`
19///
20/// If neither of these functions are available, feel free to reach out to
21/// t-types for help.
22#[derive_where(Clone, Copy, Hash, PartialEq, Eq, Debug; I: Interner)]
23#[derive(TypeVisitable_Generic, TypeFoldable_Generic)]
24#[cfg_attr(
25    feature = "nightly",
26    derive(Encodable_NoContext, Decodable_NoContext, HashStable_NoContext)
27)]
28pub enum TypingMode<I: Interner> {
29    /// When checking whether impls overlap, we check whether any obligations
30    /// are guaranteed to never hold when unifying the impls. This requires us
31    /// to be complete: we must never fail to prove something which may actually
32    /// hold.
33    ///
34    /// In this typing mode we bail with ambiguity in case its not knowable
35    /// whether a trait goal may hold, e.g. because the trait may get implemented
36    /// in a downstream or sibling crate.
37    ///
38    /// We also have to be careful when generalizing aliases inside of higher-ranked
39    /// types to not unnecessarily constrain any inference variables.
40    Coherence,
41    /// Analysis includes type inference, checking that items are well-formed, and
42    /// pretty much everything else which may emit proper type errors to the user.
43    ///
44    /// We only normalize opaque types which may get defined by the current body,
45    /// which are stored in `defining_opaque_types`.
46    ///
47    /// We also refuse to project any associated type that is marked `default`.
48    /// Non-`default` ("final") types are always projected. This is necessary in
49    /// general for soundness of specialization. However, we *could* allow projections
50    /// in fully-monomorphic cases. We choose not to, because we prefer for `default type`
51    /// to force the type definition to be treated abstractly by any consumers of the
52    /// impl. Concretely, that means that the following example will
53    /// fail to compile:
54    ///
55    /// ```compile_fail,E0308
56    /// #![feature(specialization)]
57    /// trait Assoc {
58    ///     type Output;
59    /// }
60    ///
61    /// impl<T> Assoc for T {
62    ///     default type Output = bool;
63    /// }
64    ///
65    /// fn main() {
66    ///     let x: <() as Assoc>::Output = true;
67    /// }
68    /// ```
69    Analysis { defining_opaque_types_and_generators: I::LocalDefIds },
70    /// The behavior during MIR borrowck is identical to `TypingMode::Analysis`
71    /// except that the initial value for opaque types is the type computed during
72    /// HIR typeck with unique unconstrained region inference variables.
73    ///
74    /// This is currently only used with by the new solver as it results in new
75    /// non-universal defining uses of opaque types, which is a breaking change.
76    /// See tests/ui/impl-trait/non-defining-use/as-projection-term.rs.
77    Borrowck { defining_opaque_types: I::LocalDefIds },
78    /// Any analysis after borrowck for a given body should be able to use all the
79    /// hidden types defined by borrowck, without being able to define any new ones.
80    ///
81    /// This is currently only used by the new solver, but should be implemented in
82    /// the old solver as well.
83    PostBorrowckAnalysis { defined_opaque_types: I::LocalDefIds },
84    /// After analysis, mostly during codegen and MIR optimizations, we're able to
85    /// reveal all opaque types. As the concrete type should *never* be observable
86    /// directly by the user, this should not be used by checks which may expose
87    /// such details to the user.
88    ///
89    /// There are some exceptions to this as for example `layout_of` and const-evaluation
90    /// always run in `PostAnalysis` mode, even when used during analysis. This exposes
91    /// some information about the underlying type to users, but not the type itself.
92    PostAnalysis,
93}
94
95impl<I: Interner> TypingMode<I> {
96    /// Analysis outside of a body does not define any opaque types.
97    pub fn non_body_analysis() -> TypingMode<I> {
98        TypingMode::Analysis { defining_opaque_types_and_generators: Default::default() }
99    }
100
101    pub fn typeck_for_body(cx: I, body_def_id: I::LocalDefId) -> TypingMode<I> {
102        TypingMode::Analysis {
103            defining_opaque_types_and_generators: cx
104                .opaque_types_and_coroutines_defined_by(body_def_id),
105        }
106    }
107
108    /// While typechecking a body, we need to be able to define the opaque
109    /// types defined by that body.
110    ///
111    /// FIXME: This will be removed because it's generally not correct to define
112    /// opaques outside of HIR typeck.
113    pub fn analysis_in_body(cx: I, body_def_id: I::LocalDefId) -> TypingMode<I> {
114        TypingMode::Analysis {
115            defining_opaque_types_and_generators: cx.opaque_types_defined_by(body_def_id),
116        }
117    }
118
119    pub fn borrowck(cx: I, body_def_id: I::LocalDefId) -> TypingMode<I> {
120        let defining_opaque_types = cx.opaque_types_defined_by(body_def_id);
121        if defining_opaque_types.is_empty() {
122            TypingMode::non_body_analysis()
123        } else {
124            TypingMode::Borrowck { defining_opaque_types }
125        }
126    }
127
128    pub fn post_borrowck_analysis(cx: I, body_def_id: I::LocalDefId) -> TypingMode<I> {
129        let defined_opaque_types = cx.opaque_types_defined_by(body_def_id);
130        if defined_opaque_types.is_empty() {
131            TypingMode::non_body_analysis()
132        } else {
133            TypingMode::PostBorrowckAnalysis { defined_opaque_types }
134        }
135    }
136}
137
138#[cfg_attr(feature = "nightly", rustc_diagnostic_item = "type_ir_infer_ctxt_like")]
139pub trait InferCtxtLike: Sized {
140    type Interner: Interner;
141    fn cx(&self) -> Self::Interner;
142
143    /// Whether the new trait solver is enabled. This only exists because rustc
144    /// shares code between the new and old trait solvers; for all other users,
145    /// this should always be true. If this is unknowingly false and you try to
146    /// use the new trait solver, things will break badly.
147    fn next_trait_solver(&self) -> bool {
148        true
149    }
150
151    fn typing_mode(&self) -> TypingMode<Self::Interner>;
152
153    fn universe(&self) -> ty::UniverseIndex;
154    fn create_next_universe(&self) -> ty::UniverseIndex;
155
156    fn universe_of_ty(&self, ty: ty::TyVid) -> Option<ty::UniverseIndex>;
157    fn universe_of_lt(&self, lt: ty::RegionVid) -> Option<ty::UniverseIndex>;
158    fn universe_of_ct(&self, ct: ty::ConstVid) -> Option<ty::UniverseIndex>;
159
160    fn root_ty_var(&self, var: ty::TyVid) -> ty::TyVid;
161    fn root_const_var(&self, var: ty::ConstVid) -> ty::ConstVid;
162
163    fn opportunistic_resolve_ty_var(&self, vid: ty::TyVid) -> <Self::Interner as Interner>::Ty;
164    fn opportunistic_resolve_int_var(&self, vid: ty::IntVid) -> <Self::Interner as Interner>::Ty;
165    fn opportunistic_resolve_float_var(
166        &self,
167        vid: ty::FloatVid,
168    ) -> <Self::Interner as Interner>::Ty;
169    fn opportunistic_resolve_ct_var(
170        &self,
171        vid: ty::ConstVid,
172    ) -> <Self::Interner as Interner>::Const;
173    fn opportunistic_resolve_lt_var(
174        &self,
175        vid: ty::RegionVid,
176    ) -> <Self::Interner as Interner>::Region;
177
178    fn is_changed_arg(&self, arg: <Self::Interner as Interner>::GenericArg) -> bool;
179
180    fn next_region_infer(&self) -> <Self::Interner as Interner>::Region;
181    fn next_ty_infer(&self) -> <Self::Interner as Interner>::Ty;
182    fn next_const_infer(&self) -> <Self::Interner as Interner>::Const;
183    fn fresh_args_for_item(
184        &self,
185        def_id: <Self::Interner as Interner>::DefId,
186    ) -> <Self::Interner as Interner>::GenericArgs;
187
188    fn instantiate_binder_with_infer<T: TypeFoldable<Self::Interner> + Copy>(
189        &self,
190        value: ty::Binder<Self::Interner, T>,
191    ) -> T;
192
193    fn enter_forall<T: TypeFoldable<Self::Interner>, U>(
194        &self,
195        value: ty::Binder<Self::Interner, T>,
196        f: impl FnOnce(T) -> U,
197    ) -> U;
198
199    fn equate_ty_vids_raw(&self, a: ty::TyVid, b: ty::TyVid);
200    fn equate_int_vids_raw(&self, a: ty::IntVid, b: ty::IntVid);
201    fn equate_float_vids_raw(&self, a: ty::FloatVid, b: ty::FloatVid);
202    fn equate_const_vids_raw(&self, a: ty::ConstVid, b: ty::ConstVid);
203
204    fn instantiate_ty_var_raw<R: PredicateEmittingRelation<Self>>(
205        &self,
206        relation: &mut R,
207        target_is_expected: bool,
208        target_vid: ty::TyVid,
209        instantiation_variance: ty::Variance,
210        source_ty: <Self::Interner as Interner>::Ty,
211    ) -> RelateResult<Self::Interner, ()>;
212    fn instantiate_int_var_raw(&self, vid: ty::IntVid, value: ty::IntVarValue);
213    fn instantiate_float_var_raw(&self, vid: ty::FloatVid, value: ty::FloatVarValue);
214    fn instantiate_const_var_raw<R: PredicateEmittingRelation<Self>>(
215        &self,
216        relation: &mut R,
217        target_is_expected: bool,
218        target_vid: ty::ConstVid,
219        source_ct: <Self::Interner as Interner>::Const,
220    ) -> RelateResult<Self::Interner, ()>;
221
222    fn set_tainted_by_errors(&self, e: <Self::Interner as Interner>::ErrorGuaranteed);
223
224    fn shallow_resolve(
225        &self,
226        ty: <Self::Interner as Interner>::Ty,
227    ) -> <Self::Interner as Interner>::Ty;
228    fn shallow_resolve_const(
229        &self,
230        ty: <Self::Interner as Interner>::Const,
231    ) -> <Self::Interner as Interner>::Const;
232
233    fn resolve_vars_if_possible<T>(&self, value: T) -> T
234    where
235        T: TypeFoldable<Self::Interner>;
236
237    fn probe<T>(&self, probe: impl FnOnce() -> T) -> T;
238
239    fn sub_regions(
240        &self,
241        sub: <Self::Interner as Interner>::Region,
242        sup: <Self::Interner as Interner>::Region,
243        span: <Self::Interner as Interner>::Span,
244    );
245
246    fn equate_regions(
247        &self,
248        a: <Self::Interner as Interner>::Region,
249        b: <Self::Interner as Interner>::Region,
250        span: <Self::Interner as Interner>::Span,
251    );
252
253    fn register_ty_outlives(
254        &self,
255        ty: <Self::Interner as Interner>::Ty,
256        r: <Self::Interner as Interner>::Region,
257        span: <Self::Interner as Interner>::Span,
258    );
259
260    type OpaqueTypeStorageEntries: OpaqueTypeStorageEntries;
261    fn opaque_types_storage_num_entries(&self) -> Self::OpaqueTypeStorageEntries;
262    fn clone_opaque_types_lookup_table(
263        &self,
264    ) -> Vec<(ty::OpaqueTypeKey<Self::Interner>, <Self::Interner as Interner>::Ty)>;
265    fn clone_duplicate_opaque_types(
266        &self,
267    ) -> Vec<(ty::OpaqueTypeKey<Self::Interner>, <Self::Interner as Interner>::Ty)>;
268    fn clone_opaque_types_added_since(
269        &self,
270        prev_entries: Self::OpaqueTypeStorageEntries,
271    ) -> Vec<(ty::OpaqueTypeKey<Self::Interner>, <Self::Interner as Interner>::Ty)>;
272
273    fn register_hidden_type_in_storage(
274        &self,
275        opaque_type_key: ty::OpaqueTypeKey<Self::Interner>,
276        hidden_ty: <Self::Interner as Interner>::Ty,
277        span: <Self::Interner as Interner>::Span,
278    ) -> Option<<Self::Interner as Interner>::Ty>;
279    fn add_duplicate_opaque_type(
280        &self,
281        opaque_type_key: ty::OpaqueTypeKey<Self::Interner>,
282        hidden_ty: <Self::Interner as Interner>::Ty,
283        span: <Self::Interner as Interner>::Span,
284    );
285
286    fn reset_opaque_types(&self);
287}
rustc_type_ir/infer_ctxt.rs

rustc_type_ir/
infer_ctxt.rs
