pub enum TypingMode<I>where
I: Interner,{
Coherence,
Analysis {
defining_opaque_types: <I as Interner>::DefiningOpaqueTypes,
},
PostBorrowckAnalysis {
defined_opaque_types: <I as Interner>::DefiningOpaqueTypes,
},
PostAnalysis,
}
Expand description
The current typing mode of an inference context. We unfortunately have some slightly different typing rules depending on the current context. See the doc comment for each variant for how and why they are used.
In most cases you can get the correct typing mode automically via:
mir::Body::typing_mode
rustc_lint::LateContext::typing_mode
If neither of these functions are available, feel free to reach out to t-types for help.
Variants§
Coherence
When checking whether impls overlap, we check whether any obligations are guaranteed to never hold when unifying the impls. This requires us to be complete: we must never fail to prove something which may actually hold.
In this typing mode we bail with ambiguity in case its not knowable whether a trait goal may hold, e.g. because the trait may get implemented in a downstream or sibling crate.
We also have to be careful when generalizing aliases inside of higher-ranked types to not unnecessarily constrain any inference variables.
Analysis
Analysis includes type inference, checking that items are well-formed, and pretty much everything else which may emit proper type errors to the user.
We only normalize opaque types which may get defined by the current body,
which are stored in defining_opaque_types
.
We also refuse to project any associated type that is marked default
.
Non-default
(“final”) types are always projected. This is necessary in
general for soundness of specialization. However, we could allow projections
in fully-monomorphic cases. We choose not to, because we prefer for default type
to force the type definition to be treated abstractly by any consumers of the
impl. Concretely, that means that the following example will
fail to compile:
#![feature(specialization)]
trait Assoc {
type Output;
}
impl<T> Assoc for T {
default type Output = bool;
}
fn main() {
let x: <() as Assoc>::Output = true;
}
Fields
defining_opaque_types: <I as Interner>::DefiningOpaqueTypes
PostBorrowckAnalysis
Any analysis after borrowck for a given body should be able to use all the hidden types defined by borrowck, without being able to define any new ones.
This is currently only used by the new solver, but should be implemented in the old solver as well.
Fields
defined_opaque_types: <I as Interner>::DefiningOpaqueTypes
PostAnalysis
After analysis, mostly during codegen and MIR optimizations, we’re able to reveal all opaque types. As the concrete type should never be observable directly by the user, this should not be used by checks which may expose such details to the user.
There are some exceptions to this as for example layout_of
and const-evaluation
always run in PostAnalysis
mode, even when used during analysis. This exposes
some information about the underlying type to users, but not the type itself.
Implementations§
Source§impl<I> TypingMode<I>where
I: Interner,
impl<I> TypingMode<I>where
I: Interner,
Sourcepub fn non_body_analysis() -> TypingMode<I>
pub fn non_body_analysis() -> TypingMode<I>
Analysis outside of a body does not define any opaque types.
Sourcepub fn analysis_in_body(
cx: I,
body_def_id: <I as Interner>::LocalDefId,
) -> TypingMode<I>
pub fn analysis_in_body( cx: I, body_def_id: <I as Interner>::LocalDefId, ) -> TypingMode<I>
While typechecking a body, we need to be able to define the opaque types defined by that body.
pub fn post_borrowck_analysis( cx: I, body_def_id: <I as Interner>::LocalDefId, ) -> TypingMode<I>
Trait Implementations§
Source§impl<I> Clone for TypingMode<I>where
I: Interner,
impl<I> Clone for TypingMode<I>where
I: Interner,
Source§fn clone(&self) -> TypingMode<I>
fn clone(&self) -> TypingMode<I>
1.0.0 · Source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read moreSource§impl<I> Debug for TypingMode<I>where
I: Interner,
impl<I> Debug for TypingMode<I>where
I: Interner,
Source§impl<I, __D> Decodable<__D> for TypingMode<I>
impl<I, __D> Decodable<__D> for TypingMode<I>
fn decode(__decoder: &mut __D) -> TypingMode<I>
Source§impl<I, __E> Encodable<__E> for TypingMode<I>
impl<I, __E> Encodable<__E> for TypingMode<I>
Source§impl<I> Hash for TypingMode<I>where
I: Interner,
impl<I> Hash for TypingMode<I>where
I: Interner,
Source§impl<I, __CTX> HashStable<__CTX> for TypingMode<I>
impl<I, __CTX> HashStable<__CTX> for TypingMode<I>
fn hash_stable( &self, __hcx: &mut __CTX, __hasher: &mut StableHasher<SipHasher128>, )
Source§impl<I> PartialEq for TypingMode<I>where
I: Interner,
impl<I> PartialEq for TypingMode<I>where
I: Interner,
Source§impl<I> TypeFoldable<I> for TypingMode<I>
impl<I> TypeFoldable<I> for TypingMode<I>
Source§fn try_fold_with<__F>(
self,
__folder: &mut __F,
) -> Result<TypingMode<I>, <__F as FallibleTypeFolder<I>>::Error>where
__F: FallibleTypeFolder<I>,
fn try_fold_with<__F>(
self,
__folder: &mut __F,
) -> Result<TypingMode<I>, <__F as FallibleTypeFolder<I>>::Error>where
__F: FallibleTypeFolder<I>,
Source§fn fold_with<F>(self, folder: &mut F) -> Selfwhere
F: TypeFolder<I>,
fn fold_with<F>(self, folder: &mut F) -> Selfwhere
F: TypeFolder<I>,
try_fold_with
for use with infallible
folders. Do not override this method, to ensure coherence with
try_fold_with
.Source§impl<I> TypeVisitable<I> for TypingMode<I>
impl<I> TypeVisitable<I> for TypingMode<I>
Source§fn visit_with<__V>(
&self,
__visitor: &mut __V,
) -> <__V as TypeVisitor<I>>::Resultwhere
__V: TypeVisitor<I>,
fn visit_with<__V>(
&self,
__visitor: &mut __V,
) -> <__V as TypeVisitor<I>>::Resultwhere
__V: TypeVisitor<I>,
impl<I> Copy for TypingMode<I>where
I: Interner,
impl<I> Eq for TypingMode<I>where
I: Interner,
Auto Trait Implementations§
impl<I> DynSend for TypingMode<I>
impl<I> DynSync for TypingMode<I>
impl<I> Freeze for TypingMode<I>
impl<I> RefUnwindSafe for TypingMode<I>
impl<I> Send for TypingMode<I>
impl<I> Sync for TypingMode<I>
impl<I> Unpin for TypingMode<I>
impl<I> UnwindSafe for TypingMode<I>
Blanket Implementations§
Source§impl<'tcx, T> ArenaAllocatable<'tcx, IsCopy> for Twhere
T: Copy,
impl<'tcx, T> ArenaAllocatable<'tcx, IsCopy> for Twhere
T: Copy,
fn allocate_on(self, arena: &'tcx Arena<'tcx>) -> &'tcx mut T
fn allocate_from_iter( arena: &'tcx Arena<'tcx>, iter: impl IntoIterator<Item = T>, ) -> &'tcx mut [T]
Source§impl<'tcx, T> ArenaAllocatable<'tcx, IsCopy> for Twhere
T: Copy,
impl<'tcx, T> ArenaAllocatable<'tcx, IsCopy> for Twhere
T: Copy,
fn allocate_on(self, arena: &'tcx Arena<'tcx>) -> &'tcx mut T
fn allocate_from_iter( arena: &'tcx Arena<'tcx>, iter: impl IntoIterator<Item = T>, ) -> &'tcx mut [T]
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
Source§impl<T, R> CollectAndApply<T, R> for T
impl<T, R> CollectAndApply<T, R> for T
Source§impl<Tcx, T> DepNodeParams<Tcx> for T
impl<Tcx, T> DepNodeParams<Tcx> for T
default fn fingerprint_style() -> FingerprintStyle
Source§default fn to_fingerprint(&self, tcx: Tcx) -> Fingerprint
default fn to_fingerprint(&self, tcx: Tcx) -> Fingerprint
default fn to_debug_str(&self, _: Tcx) -> String
Source§default fn recover(_: Tcx, _: &DepNode) -> Option<T>
default fn recover(_: Tcx, _: &DepNode) -> Option<T>
DepNode
,
something which is needed when forcing DepNode
s during red-green
evaluation. The query system will only call this method if
fingerprint_style()
is not FingerprintStyle::Opaque
.
It is always valid to return None
here, in which case incremental
compilation will treat the query as having changed instead of forcing it.Source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
Source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
Source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
Source§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key
and return true
if they are equal.Source§impl<T> Filterable for T
impl<T> Filterable for T
Source§fn filterable(
self,
filter_name: &'static str,
) -> RequestFilterDataProvider<T, fn(_: DataRequest<'_>) -> bool>
fn filterable( self, filter_name: &'static str, ) -> RequestFilterDataProvider<T, fn(_: DataRequest<'_>) -> bool>
Source§impl<T> Instrument for T
impl<T> Instrument for T
Source§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
Source§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
Source§impl<T> IntoEither for T
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self>
fn into_either(self, into_left: bool) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left
is true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left(&self)
returns true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moreSource§impl<P> IntoQueryParam<P> for P
impl<P> IntoQueryParam<P> for P
fn into_query_param(self) -> P
Source§impl<'tcx, T> IsSuggestable<'tcx> for T
impl<'tcx, T> IsSuggestable<'tcx> for T
Source§impl<T> MaybeResult<T> for T
impl<T> MaybeResult<T> for T
Source§impl<T> Pointable for T
impl<T> Pointable for T
Source§impl<I, T> TypeVisitableExt<I> for Twhere
I: Interner,
T: TypeVisitable<I>,
impl<I, T> TypeVisitableExt<I> for Twhere
I: Interner,
T: TypeVisitable<I>,
fn has_type_flags(&self, flags: TypeFlags) -> bool
Source§fn has_vars_bound_at_or_above(&self, binder: DebruijnIndex) -> bool
fn has_vars_bound_at_or_above(&self, binder: DebruijnIndex) -> bool
true
if self
has any late-bound regions that are either
bound by binder
or bound by some binder outside of binder
.
If binder
is ty::INNERMOST
, this indicates whether
there are any late-bound regions that appear free.fn error_reported(&self) -> Result<(), <I as Interner>::ErrorGuaranteed>
Source§fn has_vars_bound_above(&self, binder: DebruijnIndex) -> bool
fn has_vars_bound_above(&self, binder: DebruijnIndex) -> bool
true
if this type has any regions that escape binder
(and
hence are not bound by it).Source§fn has_escaping_bound_vars(&self) -> bool
fn has_escaping_bound_vars(&self) -> bool
true
if this type has regions that are not a part of the type.
For example, for<'a> fn(&'a i32)
return false
, while fn(&'a i32)
would return true
. The latter can occur when traversing through the
former. Read morefn has_aliases(&self) -> bool
fn has_opaque_types(&self) -> bool
fn has_coroutines(&self) -> bool
fn references_error(&self) -> bool
fn has_non_region_param(&self) -> bool
fn has_infer_regions(&self) -> bool
fn has_infer_types(&self) -> bool
fn has_non_region_infer(&self) -> bool
fn has_infer(&self) -> bool
fn has_placeholders(&self) -> bool
fn has_non_region_placeholders(&self) -> bool
fn has_param(&self) -> bool
Source§fn has_free_regions(&self) -> bool
fn has_free_regions(&self) -> bool
fn has_erased_regions(&self) -> bool
Source§fn has_erasable_regions(&self) -> bool
fn has_erasable_regions(&self) -> bool
Source§fn is_global(&self) -> bool
fn is_global(&self) -> bool
Source§fn has_bound_regions(&self) -> bool
fn has_bound_regions(&self) -> bool
Source§fn has_non_region_bound_vars(&self) -> bool
fn has_non_region_bound_vars(&self) -> bool
Source§fn has_bound_vars(&self) -> bool
fn has_bound_vars(&self) -> bool
Source§fn still_further_specializable(&self) -> bool
fn still_further_specializable(&self) -> bool
impl
specialization.Source§impl<I, T, U> Upcast<I, U> for Twhere
U: UpcastFrom<I, T>,
impl<I, T, U> Upcast<I, U> for Twhere
U: UpcastFrom<I, T>,
Source§impl<I, T> UpcastFrom<I, T> for T
impl<I, T> UpcastFrom<I, T> for T
fn upcast_from(from: T, _tcx: I) -> T
Source§impl<Tcx, T> Value<Tcx> for Twhere
Tcx: DepContext,
impl<Tcx, T> Value<Tcx> for Twhere
Tcx: DepContext,
default fn from_cycle_error( tcx: Tcx, cycle_error: &CycleError, _guar: ErrorGuaranteed, ) -> T
Source§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
Source§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
Source§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
impl<'a, T> Captures<'a> for Twhere
T: ?Sized,
impl<T> ErasedDestructor for Twhere
T: 'static,
impl<T> MaybeSendSync for T
Layout§
Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.