Enum rustc_hir_typeck::expectation::Expectation

pub enum Expectation<'tcx> {
    NoExpectation,
    ExpectHasType(Ty<'tcx>),
    ExpectCastableToType(Ty<'tcx>),
    ExpectRvalueLikeUnsized(Ty<'tcx>),
    IsLast(Span),
}

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.

IsLast(Span)

Implementations

impl<'a, 'tcx> Expectation<'tcx>

pub(crate) fn adjust_for_branches(
    &self,
    fcx: &FnCtxt<'a, '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,.

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>>

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.

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

impl<'tcx> Clone for Expectation<'tcx>

fn clone(&self) -> Expectation<'tcx>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'tcx> Debug for Expectation<'tcx>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'tcx> Copy for Expectation<'tcx>

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 bytes
• ExpectHasType: 12 bytes
• ExpectCastableToType: 12 bytes
• ExpectRvalueLikeUnsized: 12 bytes
• IsLast: 8 bytes