Enum rustc_hir_typeck::expectation::Expectation
source · pub(crate) enum Expectation<'tcx> {
NoExpectation,
ExpectHasType(Ty<'tcx>),
ExpectCastableToType(Ty<'tcx>),
ExpectRvalueLikeUnsized(Ty<'tcx>),
}
Expand description
When type-checking an expression, we propagate downward
whatever type hint we are able in the form of an Expectation
.
Variants§
NoExpectation
We know nothing about what type this expression should have.
ExpectHasType(Ty<'tcx>)
This expression should have the type given (or some subtype).
ExpectCastableToType(Ty<'tcx>)
This expression will be cast to the Ty
.
ExpectRvalueLikeUnsized(Ty<'tcx>)
This rvalue expression will be wrapped in &
or Box
and coerced
to &Ty
or Box<Ty>
, respectively. Ty
is [A]
or Trait
.
Implementations§
source§impl<'a, 'tcx> Expectation<'tcx>
impl<'a, 'tcx> Expectation<'tcx>
pub(crate) fn adjust_for_branches( &self, fcx: &FnCtxt<'a, 'tcx>, ) -> Expectation<'tcx>
sourcepub(crate) fn rvalue_hint(
fcx: &FnCtxt<'a, 'tcx>,
ty: Ty<'tcx>,
) -> Expectation<'tcx>
pub(crate) fn rvalue_hint( fcx: &FnCtxt<'a, 'tcx>, ty: Ty<'tcx>, ) -> Expectation<'tcx>
Provides an expectation for an rvalue expression given an optional
hint, which is not required for type safety (the resulting type might
be checked higher up, as is the case with &expr
and box expr
), but
is useful in determining the concrete type.
The primary use case is where the expected type is a fat pointer,
like &[isize]
. For example, consider the following statement:
let x: &isize = &[1, 2, 3];
In this case, the expected type for the &[1, 2, 3]
expression is
&[isize]
. If however we were to say that [1, 2, 3]
has the
expectation ExpectHasType([isize])
, that would be too strong –
[1, 2, 3]
does not have the type [isize]
but rather [isize; 3]
.
It is only the &[1, 2, 3]
expression as a whole that can be coerced
to the type &[isize]
. Therefore, we propagate this more limited hint,
which still is useful, because it informs integer literals and the like.
See the test case test/ui/coerce-expect-unsized.rs
and #20169
for examples of where this comes up,.
sourcefn resolve(self, fcx: &FnCtxt<'a, 'tcx>) -> Expectation<'tcx>
fn resolve(self, fcx: &FnCtxt<'a, 'tcx>) -> Expectation<'tcx>
Resolves expected
by a single level if it is a variable. If
there is no expected type or resolution is not possible (e.g.,
no constraints yet present), just returns self
.
pub(crate) fn to_option(self, fcx: &FnCtxt<'a, 'tcx>) -> Option<Ty<'tcx>>
sourcepub(crate) fn only_has_type(self, fcx: &FnCtxt<'a, 'tcx>) -> Option<Ty<'tcx>>
pub(crate) fn only_has_type(self, fcx: &FnCtxt<'a, 'tcx>) -> Option<Ty<'tcx>>
It sometimes happens that we want to turn an expectation into
a hard constraint (i.e., something that must be satisfied
for the program to type-check). only_has_type
will return
such a constraint, if it exists.
sourcepub(crate) fn coercion_target_type(
self,
fcx: &FnCtxt<'a, 'tcx>,
span: Span,
) -> Ty<'tcx>
pub(crate) fn coercion_target_type( self, fcx: &FnCtxt<'a, 'tcx>, span: Span, ) -> Ty<'tcx>
Like only_has_type
, but instead of returning None
if no
hard constraint exists, creates a fresh type variable.
Trait Implementations§
source§impl<'tcx> Clone for Expectation<'tcx>
impl<'tcx> Clone for Expectation<'tcx>
source§fn clone(&self) -> Expectation<'tcx>
fn clone(&self) -> Expectation<'tcx>
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read moresource§impl<'tcx> Debug for Expectation<'tcx>
impl<'tcx> Debug for Expectation<'tcx>
impl<'tcx> Copy for Expectation<'tcx>
Auto Trait Implementations§
impl<'tcx> Freeze for Expectation<'tcx>
impl<'tcx> !RefUnwindSafe for Expectation<'tcx>
impl<'tcx> Send for Expectation<'tcx>
impl<'tcx> Sync for Expectation<'tcx>
impl<'tcx> Unpin for Expectation<'tcx>
impl<'tcx> !UnwindSafe for Expectation<'tcx>
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<'a>(self, arena: &'a Arena<'tcx>) -> &'a mut T
fn allocate_from_iter<'a>( arena: &'a Arena<'tcx>, iter: impl IntoIterator<Item = T>, ) -> &'a 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<'a>(self, arena: &'a Arena<'tcx>) -> &'a mut T
fn allocate_from_iter<'a>( arena: &'a Arena<'tcx>, iter: impl IntoIterator<Item = T>, ) -> &'a 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§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)source§impl<T, R> CollectAndApply<T, R> for T
impl<T, R> CollectAndApply<T, R> for T
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<T> MaybeResult<T> for T
impl<T> MaybeResult<T> for T
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: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...)
attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.
Size: 16 bytes
Size for each variant:
NoExpectation
: 0 bytesExpectHasType
: 8 bytesExpectCastableToType
: 8 bytesExpectRvalueLikeUnsized
: 8 bytes