## TypeRelating

# Struct TypeRelating

Source

    pub(crate) struct TypeRelating<'infcx, 'tcx> {
        infcx: &'infcx InferCtxt<'tcx>,
        trace: TypeTrace<'tcx>,
        param_env: ParamEnv<'tcx>,
        define_opaque_types: DefineOpaqueTypes,
        ambient_variance: Variance,
        obligations: PredicateObligations<'tcx>,
        cache: DelayedSet<(Variance, Ty<'tcx>, Ty<'tcx>)>,
    }

Expand description

Enforce that `a` is equal to or a subtype of `b`.

## Fields§

§`infcx: &'infcx InferCtxt<'tcx>`§`trace: TypeTrace<'tcx>`§`param_env: ParamEnv<'tcx>`§`define_opaque_types: DefineOpaqueTypes`§`ambient_variance: Variance`§`obligations: PredicateObligations<'tcx>`§`cache: DelayedSet<(Variance, Ty<'tcx>, Ty<'tcx>)>`

The cache only tracks the `ambient_variance` as it’s the only field which is mutable and which meaningfully changes the result when relating types.

The cache does not track whether the state of the `InferCtxt` has been changed or whether we’ve added any obligations to `self.goals`. Whether a goal is added once or multiple times is not really meaningful.

Changes in the inference state may delay some type inference to the next fulfillment loop. Given that this loop is already necessary, this is also not a meaningful change. Consider the following three relations:

    Vec<?0> sub Vec<?1>
    ?0 eq u32
    Vec<?0> sub Vec<?1>

Without a cache, the second `Vec<?0> sub Vec<?1>` would eagerly constrain `?1` to `u32`. When using the cache entry from the first time we’ve related these types, this only happens when later proving the `Subtype(?0, ?1)` goal from the first relation.

## Implementations§

Source§

### impl<'infcx, 'tcx> TypeRelating<'infcx, 'tcx>

Source

#### pub(crate) fn new( infcx: &'infcx InferCtxt<'tcx>, trace: TypeTrace<'tcx>, param_env: ParamEnv<'tcx>, define_opaque_types: DefineOpaqueTypes, ambient_variance: Variance, ) -> TypeRelating<'infcx, 'tcx>

Source

#### pub(crate) fn into_obligations(self) -> PredicateObligations<'tcx>

## Trait Implementations§

Source§

### impl<'tcx> PredicateEmittingRelation<InferCtxt<'tcx>> for TypeRelating<'_, 'tcx>

Source§

#### fn span(&self) -> Span

Source§

#### fn param_env(&self) -> ParamEnv<'tcx>

Source§

#### fn structurally_relate_aliases(&self) -> StructurallyRelateAliases

Whether aliases should be related structurally. This is pretty much always `No` unless you’re equating in some specific locations of the new solver. See the comments in these use-cases for more details.
Source§

#### fn register_predicates( &mut self, preds: impl IntoIterator<Item: Upcast<TyCtxt<'tcx>, Predicate<'tcx>>>, )

Register predicates that must hold in order for this relation to hold. This uses the default `param_env` of the obligation.
Source§

#### fn register_goals( &mut self, goals: impl IntoIterator<Item = Goal<'tcx, Predicate<'tcx>>>, )

Register obligations that must hold in order for this relation to hold
Source§

#### fn register_alias_relate_predicate(&mut self, a: Ty<'tcx>, b: Ty<'tcx>)

Register `AliasRelate` obligation(s) that both types must be related to each other.
Source§

### impl<'tcx> TypeRelation<TyCtxt<'tcx>> for TypeRelating<'_, 'tcx>

Source§

#### fn cx(&self) -> TyCtxt<'tcx>

Source§

#### fn relate_ty_args( &mut self, a_ty: Ty<'tcx>, b_ty: Ty<'tcx>, def_id: DefId, a_args: GenericArgsRef<'tcx>, b_args: GenericArgsRef<'tcx>, _: impl FnOnce(GenericArgsRef<'tcx>) -> Ty<'tcx>, ) -> RelateResult<'tcx, Ty<'tcx>>

Source§

#### fn relate_with_variance<T: Relate<TyCtxt<'tcx>>>( &mut self, variance: Variance, _info: VarianceDiagInfo<TyCtxt<'tcx>>, a: T, b: T, ) -> RelateResult<'tcx, T>

Switch variance for the purpose of relating `a` and `b`.
Source§

#### fn tys(&mut self, a: Ty<'tcx>, b: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>>

Source§

#### fn regions( &mut self, a: Region<'tcx>, b: Region<'tcx>, ) -> RelateResult<'tcx, Region<'tcx>>

Source§

#### fn consts( &mut self, a: Const<'tcx>, b: Const<'tcx>, ) -> RelateResult<'tcx, Const<'tcx>>

Source§

#### fn binders<T>( &mut self, a: Binder<'tcx, T>, b: Binder<'tcx, T>, ) -> RelateResult<'tcx, Binder<'tcx, T>>
where T: Relate<TyCtxt<'tcx>>,

§

#### fn relate<T>(&mut self, a: T, b: T) -> Result<T, TypeError<I>>
where T: Relate<I>,

Generic relation routine suitable for most anything.

## Auto Trait Implementations§

§

### impl<'infcx, 'tcx> !DynSend for TypeRelating<'infcx, 'tcx>

§

### impl<'infcx, 'tcx> !DynSync for TypeRelating<'infcx, 'tcx>

§

### impl<'infcx, 'tcx> Freeze for TypeRelating<'infcx, 'tcx>

§

### impl<'infcx, 'tcx> !RefUnwindSafe for TypeRelating<'infcx, 'tcx>

§

### impl<'infcx, 'tcx> !Send for TypeRelating<'infcx, 'tcx>

§

### impl<'infcx, 'tcx> !Sync for TypeRelating<'infcx, 'tcx>

§

### impl<'infcx, 'tcx> Unpin for TypeRelating<'infcx, 'tcx>

§

### impl<'infcx, 'tcx> !UnwindSafe for TypeRelating<'infcx, 'tcx>

## Blanket Implementations§

§

### impl<T> Aligned for T

§

#### const ALIGN: Alignment

Alignment of `Self`.
§

### impl<T> Any for T
where T: 'static + ?Sized,

§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
§

### impl<T> Borrow<T> for T
where T: ?Sized,

§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
§

### impl<T> BorrowMut<T> for T
where T: ?Sized,

§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

### impl<T, R> CollectAndApply<T, R> for T

§

#### fn collect_and_apply<I, F>(iter: I, f: F) -> R
where I: Iterator<Item = T>, F: FnOnce(&[T]) -> R,

Equivalent to `f(&iter.collect::<Vec<_>>())`.

§

#### type Output = R

§

### impl<T> From<T> for T

§

#### fn from(t: T) -> T

Returns the argument unchanged.

§

### impl<T> Instrument for T

§

#### fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided `Span`, returning an `Instrumented` wrapper. Read more
§

#### fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current `Span`, returning an `Instrumented` wrapper. Read more
§

### impl<T, U> Into<U> for T
where U: From<T>,

§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

§

### impl<T> IntoEither for T

§

#### fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts `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 more
§

#### fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts `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 more
§

### impl<P> IntoQueryParam<P> for P

§

#### fn into_query_param(self) -> P

§

### impl<T> MaybeResult<T> for T

§

#### type Error = !

§

#### fn from(_: Result<T, <T as MaybeResult<T>>::Error>) -> T

§

#### fn to_result(self) -> Result<T, <T as MaybeResult<T>>::Error>

§

### impl<T> Pointable for T

§

#### const ALIGN: usize

The alignment of pointer.
§

#### type Init = T

The type for initializers.
§

#### unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

#### unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

#### unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

#### unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
§

### impl<T> Same for T

§

#### type Output = T

Should always be `Self`
§

### impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

#### type Error = Infallible

The type returned in the event of a conversion error.
§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
§

### impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

### impl<I, T, U> Upcast<I, U> for T
where U: UpcastFrom<I, T>,

§

#### fn upcast(self, interner: I) -> U

§

### impl<I, T> UpcastFrom<I, T> for T

§

#### fn upcast_from(from: T, _tcx: I) -> T

§

### impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

#### fn vzip(self) -> V

§

### impl<Tcx, T> Value<Tcx> for T
where Tcx: DepContext,

§

#### default fn from_cycle_error( tcx: Tcx, cycle_error: &CycleError, _guar: ErrorGuaranteed, ) -> T

§

### impl<T> WithSubscriber for T

§

#### fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more
§

#### fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more
§

### impl<T> ErasedDestructor for T
where T: 'static,

## 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: 160 bytes