# Struct rustc_infer::infer::canonical::query_response::QueryTypeRelatingDelegate

source ·

    struct QueryTypeRelatingDelegate<'a, 'tcx> {
        infcx: &'a InferCtxt<'tcx>,
        obligations: &'a mut Vec<PredicateObligation<'tcx>>,
        param_env: ParamEnv<'tcx>,
        cause: &'a ObligationCause<'tcx>,
    }

## Fields§

§`infcx: &'a InferCtxt<'tcx>`§`obligations: &'a mut Vec<PredicateObligation<'tcx>>`§`param_env: ParamEnv<'tcx>`§`cause: &'a ObligationCause<'tcx>`

## Trait Implementations§

source§

### impl<'tcx> TypeRelatingDelegate<'tcx> for QueryTypeRelatingDelegate<'_, 'tcx>

source§

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

source§

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

source§

#### fn create_next_universe(&mut self) -> UniverseIndex

Creates a new universe index. Used when instantiating placeholders.
source§

#### fn next_existential_region_var( &mut self, from_forall: bool, _name: Option<Symbol> ) -> Region<'tcx>

Creates a new region variable representing a higher-ranked region that is instantiated existentially. This creates an inference variable, typically. Read more
source§

#### fn next_placeholder_region( &mut self, placeholder: PlaceholderRegion ) -> Region<'tcx>

Creates a new region variable representing a higher-ranked region that is instantiated universally. This creates a new region placeholder, typically. Read more
source§

#### fn generalize_existential(&mut self, universe: UniverseIndex) -> Region<'tcx>

Creates a new existential region in the given universe. This is used when handling subtyping and type variables – if we have that `?X <: Foo<'a>`, for example, we would instantiate `?X` with a type like `Foo<'?0>` where `'?0` is a fresh existential variable created by this function. We would then relate `Foo<'?0>` with `Foo<'a>` (and probably add an outlives relation stating that `'?0: 'a`).
source§

#### fn push_outlives( &mut self, sup: Region<'tcx>, sub: Region<'tcx>, _info: VarianceDiagInfo<'tcx> )

Push a constraint `sup: sub` – this constraint must be satisfied for the two types to be related. `sub` and `sup` may be regions from the type or new variables created through the delegate.
source§

#### fn forbid_inference_vars() -> bool

Enables some optimizations if we do not expect inference variables in the RHS of the relation.
source§

#### fn register_obligations(&mut self, obligations: PredicateObligations<'tcx>)

## Auto Trait Implementations§

§

### impl<'a, 'tcx> !RefUnwindSafe for QueryTypeRelatingDelegate<'a, 'tcx>

§

### impl<'a, 'tcx> !Send for QueryTypeRelatingDelegate<'a, 'tcx>

§

### impl<'a, 'tcx> !Sync for QueryTypeRelatingDelegate<'a, 'tcx>

§

### impl<'a, 'tcx> Unpin for QueryTypeRelatingDelegate<'a, 'tcx>

§

### impl<'a, 'tcx> !UnwindSafe for QueryTypeRelatingDelegate<'a, 'tcx>

## Blanket Implementations§

source§

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

source§

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

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

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

source§

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

Immutably borrows from an owned value. Read more
source§

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

source§

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

Mutably borrows from an owned value. Read more
source§

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

source§

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

Returns the argument unchanged.

source§

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

source§

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

Calls `U::from(self)`.

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

source§

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

§

#### type Error = Infallible

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

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

Performs the conversion.
source§

### 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.
source§

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

Performs the conversion.

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