Enum Expectation 

pub(crate) enum Expectation<'db> {
    None,
    HasType(Ty<'db>),
    Castable(Ty<'db>),
    RValueLikeUnsized(Ty<'db>),
}

When inferring an expression, we propagate downward whatever type hint we are able in the form of an Expectation.

Variants

None

HasType(Ty<'db>)

Castable(Ty<'db>)

RValueLikeUnsized(Ty<'db>)

Implementations

impl<'db> Expectation<'db>

fn has_type(ty: Ty<'db>) -> Self

The expectation that the type of the expression needs to equal the given type.

fn rvalue_hint(ctx: &mut InferenceContext<'db>, ty: Ty<'db>) -> Self

The following explanation is copied straight from rustc: 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 it: &[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 none() -> Self

This expresses no expectation on the type.

fn resolve(&self, table: &InferenceTable<'db>) -> Expectation<'db>

fn to_option(&self, table: &InferenceTable<'db>) -> Option<Ty<'db>>

fn only_has_type(&self, table: &mut InferenceTable<'db>) -> Option<Ty<'db>>

fn coercion_target_type( &self, table: &mut InferenceTable<'db>, span: Span, ) -> Ty<'db>

fn adjust_for_branches( &self, table: &mut InferenceTable<'db>, span: Span, ) -> Expectation<'db>

Comment copied from rustc: Disregard “castable to” expectations because they can lead us astray. Consider for example if cond {22} else {c} as u8 – if we propagate the “castable to u8” constraint to 22, it will pick the type 22u8, which is overly constrained (c might not be a u8). In effect, the problem is that the “castable to” expectation is not the tightest thing we can say, so we want to drop it in this case. The tightest thing we can say is “must unify with else branch”. Note that in the case of a “has type” constraint, this limitation does not hold.

If the expected type is just a type variable, then don’t use an expected type. Otherwise, we might write parts of the type when checking the ‘then’ block which are incompatible with the ‘else’ branch.

Trait Implementations

impl<'db> Clone for Expectation<'db>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'db> Debug for Expectation<'db>

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

Formats the value using the given formatter.

impl<'db> PartialEq for Expectation<'db>

fn eq(&self, other: &Expectation<'db>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'db> Eq for Expectation<'db>

impl<'db> StructuralPartialEq for Expectation<'db>