rustc_type_ir/
infer_ctxt.rs

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

rustc_type_ir/
infer_ctxt.rs
