Trait rustc_infer::infer::nll_relate::TypeRelatingDelegate

source · 
pub trait TypeRelatingDelegate<'tcx> {
    fn param_env(&self) -> ParamEnv<'tcx>;
    fn span(&self) -> Span;
    fn push_outlives(
        &mut self,
        sup: Region<'tcx>,
        sub: Region<'tcx>,
        info: VarianceDiagInfo<'tcx>
    );
    fn const_equate(&mut self, a: Const<'tcx>, b: Const<'tcx>);
    fn register_opaque_type(
        &mut self,
        a: Ty<'tcx>,
        b: Ty<'tcx>,
        a_is_expected: bool
    ) -> Result<(), TypeError<'tcx>>;
    fn create_next_universe(&mut self) -> UniverseIndex;
    fn next_existential_region_var(
        &mut self,
        was_placeholder: bool
    ) -> Region<'tcx>;
    fn next_placeholder_region(
        &mut self,
        placeholder: PlaceholderRegion
    ) -> Region<'tcx>;
    fn generalize_existential(&mut self, universe: UniverseIndex) -> Region<'tcx>;
    fn normalization() -> NormalizationStrategy;
    fn forbid_inference_vars() -> bool;
}

Required Methods

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.

Creates a new universe index. Used when instantiating placeholders.

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

So e.g., if you have for<'a> fn(..) <: for<'b> fn(..), then we will invoke this method to instantiate 'a with an inference variable (though 'b would be instantiated first, as a placeholder).

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

So e.g., if you have for<'a> fn(..) <: for<'b> fn(..), then we will invoke this method to instantiate 'b with a placeholder region.

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

Define the normalization strategy to use, eager or lazy.

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

Implementors