Enum OpaqueTypesJank 

pub enum OpaqueTypesJank {
    AllGood,
    ErrorIfRigidSelfTy,
}

Supporting not-yet-defined opaque types in HIR typeck is somewhat challenging. Ideally we’d normalize them to a new inference variable and just defer type inference which relies on the opaque until we’ve constrained the hidden type.

This doesn’t work for method and function calls as we need to guide type inference for the function arguments. We treat not-yet-defined opaque types as if they were rigid instead in these places.

When we encounter a ?hidden_type_of_opaque: Trait<?var> goal, we use the item bounds and blanket impls to guide inference by constraining other type variables, see EvalCtxt::try_assemble_bounds_via_registered_opaques. We always keep the certainty as Maybe so that we properly prove these goals once the hidden type has been constrained.

If we fail to prove the trait goal via item bounds or blanket impls, the goal would have errored if the opaque type were rigid. In this case, we set OpaqueTypesJank::ErrorIfRigidSelfTy in the Certainty.

Places in HIR typeck where we want to treat not-yet-defined opaque types as if they were kind of rigid then use fn root_goal_may_hold_opaque_types_jank which returns false if the goal doesn’t hold or if OpaqueTypesJank::ErrorIfRigidSelfTy is set (i.e. proving it required relies on some ?hidden_ty: NotInItemBounds goal).

This is subtly different from actually treating not-yet-defined opaque types as rigid, e.g. it allows constraining opaque types if they are not the self-type of a goal. It is good enough for now and only matters for very rare type inference edge cases. We can improve this later on if necessary.

Variants

AllGood

ErrorIfRigidSelfTy

Implementations

impl OpaqueTypesJank

fn and(self, other: OpaqueTypesJank) -> OpaqueTypesJank

pub fn or(self, other: OpaqueTypesJank) -> OpaqueTypesJank

Trait Implementations

impl Clone for OpaqueTypesJank

fn clone(&self) -> OpaqueTypesJank

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OpaqueTypesJank

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

Formats the value using the given formatter.

impl Hash for OpaqueTypesJank

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<__CTX> HashStable<__CTX> for OpaqueTypesJank

fn hash_stable(&self, __hcx: &mut __CTX, __hasher: &mut StableHasher)

impl PartialEq for OpaqueTypesJank

fn eq(&self, other: &OpaqueTypesJank) -> 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 Copy for OpaqueTypesJank

impl Eq for OpaqueTypesJank

impl StructuralPartialEq for OpaqueTypesJank

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: 1 byte

Size for each variant:

• AllGood: 0 bytes
• ErrorIfRigidSelfTy: 0 bytes