Trait Interner

pub trait Interner:
    Sized
    + Copy
    + IrPrint<AliasTy<Self>>
    + IrPrint<AliasTerm<Self>>
    + IrPrint<TraitRef<Self>>
    + IrPrint<TraitPredicate<Self>>
    + IrPrint<HostEffectPredicate<Self>>
    + IrPrint<ExistentialTraitRef<Self>>
    + IrPrint<ExistentialProjection<Self>>
    + IrPrint<ProjectionPredicate<Self>>
    + IrPrint<NormalizesTo<Self>>
    + IrPrint<SubtypePredicate<Self>>
    + IrPrint<CoercePredicate<Self>>
    + IrPrint<FnSig<Self>> {
    type DefId: DefId<Self>;
    type LocalDefId: Copy + Debug + Hash + Eq + Into<Self::DefId> + TypeFoldable<Self>;
    type Span: Span<Self>;
    type GenericArgs: GenericArgs<Self>;
    type GenericArgsSlice: Copy + Debug + Hash + Eq + SliceLike<Item = Self::GenericArg>;
    type GenericArg: GenericArg<Self>;
    type Term: Term<Self>;
    type BoundVarKinds: Copy + Debug + Hash + Eq + SliceLike<Item = Self::BoundVarKind> + Default;
    type BoundVarKind: Copy + Debug + Hash + Eq;
    type PredefinedOpaques: Copy + Debug + Hash + Eq + TypeFoldable<Self> + Deref<Target = PredefinedOpaquesData<Self>>;
    type DefiningOpaqueTypes: Copy + Debug + Hash + Default + Eq + TypeVisitable<Self> + SliceLike<Item = Self::LocalDefId>;
    type CanonicalVars: Copy + Debug + Hash + Eq + SliceLike<Item = CanonicalVarInfo<Self>> + Default;
    type ExternalConstraints: Copy + Debug + Hash + Eq + TypeFoldable<Self> + Deref<Target = ExternalConstraintsData<Self>>;
    type DepNodeIndex;
    type Tracked<T: Debug + Clone>: Debug;
    type Ty: Ty<Self>;
    type Tys: Tys<Self>;
    type FnInputTys: Copy + Debug + Hash + Eq + SliceLike<Item = Self::Ty> + TypeVisitable<Self>;
    type ParamTy: Copy + Debug + Hash + Eq + ParamLike;
    type BoundTy: Copy + Debug + Hash + Eq + BoundVarLike<Self>;
    type PlaceholderTy: PlaceholderLike;
    type ErrorGuaranteed: Copy + Debug + Hash + Eq;
    type BoundExistentialPredicates: BoundExistentialPredicates<Self>;
    type AllocId: Copy + Debug + Hash + Eq;
    type Pat: Copy + Debug + Hash + Eq + Relate<Self>;
    type Safety: Safety<Self>;
    type Abi: Abi<Self>;
    type Const: Const<Self>;
    type PlaceholderConst: PlaceholderLike;
    type ParamConst: Copy + Debug + Hash + Eq + ParamLike;
    type BoundConst: Copy + Debug + Hash + Eq + BoundVarLike<Self>;
    type ValueConst: Copy + Debug + Hash + Eq;
    type ExprConst: ExprConst<Self>;
    type Region: Region<Self>;
    type EarlyParamRegion: Copy + Debug + Hash + Eq + ParamLike;
    type LateParamRegion: Copy + Debug + Hash + Eq;
    type BoundRegion: Copy + Debug + Hash + Eq + BoundVarLike<Self>;
    type PlaceholderRegion: PlaceholderLike;
    type ParamEnv: ParamEnv<Self>;
    type Predicate: Predicate<Self>;
    type Clause: Clause<Self>;
    type Clauses: Copy + Debug + Hash + Eq + TypeSuperVisitable<Self> + Flags;
    type GenericsOf: GenericsOf<Self>;
    type VariancesOf: Copy + Debug + SliceLike<Item = Variance>;
    type AdtDef: AdtDef<Self>;
    type Features: Features<Self>;
    type UnsizingParams: Deref<Target = BitSet<u32>>;

    // Required methods
    fn mk_predefined_opaques_in_body(
        self,
        data: PredefinedOpaquesData<Self>,
    ) -> Self::PredefinedOpaques;
    fn mk_canonical_var_infos(
        self,
        infos: &[CanonicalVarInfo<Self>],
    ) -> Self::CanonicalVars;
    fn mk_external_constraints(
        self,
        data: ExternalConstraintsData<Self>,
    ) -> Self::ExternalConstraints;
    fn mk_tracked<T: Debug + Clone>(
        self,
        data: T,
        dep_node: Self::DepNodeIndex,
    ) -> Self::Tracked<T>;
    fn get_tracked<T: Debug + Clone>(self, tracked: &Self::Tracked<T>) -> T;
    fn with_cached_task<T>(
        self,
        task: impl FnOnce() -> T,
    ) -> (T, Self::DepNodeIndex);
    fn with_global_cache<R>(
        self,
        f: impl FnOnce(&mut GlobalCache<Self>) -> R,
    ) -> R;
    fn evaluation_is_concurrent(&self) -> bool;
    fn expand_abstract_consts<T: TypeFoldable<Self>>(self, t: T) -> T;
    fn generics_of(self, def_id: Self::DefId) -> Self::GenericsOf;
    fn variances_of(self, def_id: Self::DefId) -> Self::VariancesOf;
    fn type_of(self, def_id: Self::DefId) -> EarlyBinder<Self, Self::Ty>;
    fn adt_def(self, adt_def_id: Self::DefId) -> Self::AdtDef;
    fn alias_ty_kind(self, alias: AliasTy<Self>) -> AliasTyKind;
    fn alias_term_kind(self, alias: AliasTerm<Self>) -> AliasTermKind;
    fn trait_ref_and_own_args_for_alias(
        self,
        def_id: Self::DefId,
        args: Self::GenericArgs,
    ) -> (TraitRef<Self>, Self::GenericArgsSlice);
    fn mk_args(self, args: &[Self::GenericArg]) -> Self::GenericArgs;
    fn mk_args_from_iter<I, T>(self, args: I) -> T::Output
       where I: Iterator<Item = T>,
             T: CollectAndApply<Self::GenericArg, Self::GenericArgs>;
    fn check_args_compatible(
        self,
        def_id: Self::DefId,
        args: Self::GenericArgs,
    ) -> bool;
    fn debug_assert_args_compatible(
        self,
        def_id: Self::DefId,
        args: Self::GenericArgs,
    );
    fn debug_assert_existential_args_compatible(
        self,
        def_id: Self::DefId,
        args: Self::GenericArgs,
    );
    fn mk_type_list_from_iter<I, T>(self, args: I) -> T::Output
       where I: Iterator<Item = T>,
             T: CollectAndApply<Self::Ty, Self::Tys>;
    fn parent(self, def_id: Self::DefId) -> Self::DefId;
    fn recursion_limit(self) -> usize;
    fn features(self) -> Self::Features;
    fn bound_coroutine_hidden_types(
        self,
        def_id: Self::DefId,
    ) -> impl IntoIterator<Item = EarlyBinder<Self, Binder<Self, Self::Ty>>>;
    fn fn_sig(
        self,
        def_id: Self::DefId,
    ) -> EarlyBinder<Self, Binder<Self, FnSig<Self>>>;
    fn coroutine_movability(self, def_id: Self::DefId) -> Movability;
    fn coroutine_for_closure(self, def_id: Self::DefId) -> Self::DefId;
    fn generics_require_sized_self(self, def_id: Self::DefId) -> bool;
    fn item_bounds(
        self,
        def_id: Self::DefId,
    ) -> EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>>;
    fn predicates_of(
        self,
        def_id: Self::DefId,
    ) -> EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>>;
    fn own_predicates_of(
        self,
        def_id: Self::DefId,
    ) -> EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>>;
    fn explicit_super_predicates_of(
        self,
        def_id: Self::DefId,
    ) -> EarlyBinder<Self, impl IntoIterator<Item = (Self::Clause, Self::Span)>>;
    fn explicit_implied_predicates_of(
        self,
        def_id: Self::DefId,
    ) -> EarlyBinder<Self, impl IntoIterator<Item = (Self::Clause, Self::Span)>>;
    fn impl_is_const(self, def_id: Self::DefId) -> bool;
    fn fn_is_const(self, def_id: Self::DefId) -> bool;
    fn alias_has_const_conditions(self, def_id: Self::DefId) -> bool;
    fn const_conditions(
        self,
        def_id: Self::DefId,
    ) -> EarlyBinder<Self, impl IntoIterator<Item = Binder<Self, TraitRef<Self>>>>;
    fn explicit_implied_const_bounds(
        self,
        def_id: Self::DefId,
    ) -> EarlyBinder<Self, impl IntoIterator<Item = Binder<Self, TraitRef<Self>>>>;
    fn has_target_features(self, def_id: Self::DefId) -> bool;
    fn require_lang_item(self, lang_item: TraitSolverLangItem) -> Self::DefId;
    fn is_lang_item(
        self,
        def_id: Self::DefId,
        lang_item: TraitSolverLangItem,
    ) -> bool;
    fn as_lang_item(self, def_id: Self::DefId) -> Option<TraitSolverLangItem>;
    fn associated_type_def_ids(
        self,
        def_id: Self::DefId,
    ) -> impl IntoIterator<Item = Self::DefId>;
    fn for_each_relevant_impl(
        self,
        trait_def_id: Self::DefId,
        self_ty: Self::Ty,
        f: impl FnMut(Self::DefId),
    );
    fn has_item_definition(self, def_id: Self::DefId) -> bool;
    fn impl_is_default(self, impl_def_id: Self::DefId) -> bool;
    fn impl_trait_ref(
        self,
        impl_def_id: Self::DefId,
    ) -> EarlyBinder<Self, TraitRef<Self>>;
    fn impl_polarity(self, impl_def_id: Self::DefId) -> ImplPolarity;
    fn trait_is_auto(self, trait_def_id: Self::DefId) -> bool;
    fn trait_is_alias(self, trait_def_id: Self::DefId) -> bool;
    fn trait_is_dyn_compatible(self, trait_def_id: Self::DefId) -> bool;
    fn trait_is_fundamental(self, def_id: Self::DefId) -> bool;
    fn trait_may_be_implemented_via_object(
        self,
        trait_def_id: Self::DefId,
    ) -> bool;
    fn is_impl_trait_in_trait(self, def_id: Self::DefId) -> bool;
    fn delay_bug(self, msg: impl ToString) -> Self::ErrorGuaranteed;
    fn is_general_coroutine(self, coroutine_def_id: Self::DefId) -> bool;
    fn coroutine_is_async(self, coroutine_def_id: Self::DefId) -> bool;
    fn coroutine_is_gen(self, coroutine_def_id: Self::DefId) -> bool;
    fn coroutine_is_async_gen(self, coroutine_def_id: Self::DefId) -> bool;
    fn unsizing_params_for_adt(
        self,
        adt_def_id: Self::DefId,
    ) -> Self::UnsizingParams;
    fn find_const_ty_from_env(
        self,
        param_env: Self::ParamEnv,
        placeholder: Self::PlaceholderConst,
    ) -> Self::Ty;
    fn anonymize_bound_vars<T: TypeFoldable<Self>>(
        self,
        binder: Binder<Self, T>,
    ) -> Binder<Self, T>;
    fn opaque_types_defined_by(
        self,
        defining_anchor: Self::LocalDefId,
    ) -> Self::DefiningOpaqueTypes;
}

Required Associated Types

type DefId: DefId<Self>

type LocalDefId: Copy + Debug + Hash + Eq + Into<Self::DefId> + TypeFoldable<Self>

type Span: Span<Self>

type GenericArgs: GenericArgs<Self>

type GenericArgsSlice: Copy + Debug + Hash + Eq + SliceLike<Item = Self::GenericArg>

type GenericArg: GenericArg<Self>

type Term: Term<Self>

type BoundVarKinds: Copy + Debug + Hash + Eq + SliceLike<Item = Self::BoundVarKind> + Default

type BoundVarKind: Copy + Debug + Hash + Eq

type PredefinedOpaques: Copy + Debug + Hash + Eq + TypeFoldable<Self> + Deref<Target = PredefinedOpaquesData<Self>>

type DefiningOpaqueTypes: Copy + Debug + Hash + Default + Eq + TypeVisitable<Self> + SliceLike<Item = Self::LocalDefId>

type CanonicalVars: Copy + Debug + Hash + Eq + SliceLike<Item = CanonicalVarInfo<Self>> + Default

type ExternalConstraints: Copy + Debug + Hash + Eq + TypeFoldable<Self> + Deref<Target = ExternalConstraintsData<Self>>

type DepNodeIndex

type Tracked<T: Debug + Clone>: Debug

type Ty: Ty<Self>

type Tys: Tys<Self>

type FnInputTys: Copy + Debug + Hash + Eq + SliceLike<Item = Self::Ty> + TypeVisitable<Self>

type ParamTy: Copy + Debug + Hash + Eq + ParamLike

type BoundTy: Copy + Debug + Hash + Eq + BoundVarLike<Self>

type PlaceholderTy: PlaceholderLike

type ErrorGuaranteed: Copy + Debug + Hash + Eq

type BoundExistentialPredicates: BoundExistentialPredicates<Self>

type AllocId: Copy + Debug + Hash + Eq

type Pat: Copy + Debug + Hash + Eq + Relate<Self>

type Safety: Safety<Self>

type Abi: Abi<Self>

type Const: Const<Self>

type PlaceholderConst: PlaceholderLike

type ParamConst: Copy + Debug + Hash + Eq + ParamLike

type BoundConst: Copy + Debug + Hash + Eq + BoundVarLike<Self>

type ValueConst: Copy + Debug + Hash + Eq

type ExprConst: ExprConst<Self>

type Region: Region<Self>

type EarlyParamRegion: Copy + Debug + Hash + Eq + ParamLike

type LateParamRegion: Copy + Debug + Hash + Eq

type BoundRegion: Copy + Debug + Hash + Eq + BoundVarLike<Self>

type PlaceholderRegion: PlaceholderLike

type ParamEnv: ParamEnv<Self>

type Predicate: Predicate<Self>

type Clause: Clause<Self>

type Clauses: Copy + Debug + Hash + Eq + TypeSuperVisitable<Self> + Flags

type GenericsOf: GenericsOf<Self>

type VariancesOf: Copy + Debug + SliceLike<Item = Variance>

type AdtDef: AdtDef<Self>

type Features: Features<Self>

type UnsizingParams: Deref<Target = BitSet<u32>>

Required Methods

fn mk_predefined_opaques_in_body( self, data: PredefinedOpaquesData<Self>, ) -> Self::PredefinedOpaques

fn mk_canonical_var_infos( self, infos: &[CanonicalVarInfo<Self>], ) -> Self::CanonicalVars

fn mk_external_constraints( self, data: ExternalConstraintsData<Self>, ) -> Self::ExternalConstraints

fn mk_tracked<T: Debug + Clone>( self, data: T, dep_node: Self::DepNodeIndex, ) -> Self::Tracked<T>

fn get_tracked<T: Debug + Clone>(self, tracked: &Self::Tracked<T>) -> T

fn with_cached_task<T>( self, task: impl FnOnce() -> T, ) -> (T, Self::DepNodeIndex)

fn with_global_cache<R>(self, f: impl FnOnce(&mut GlobalCache<Self>) -> R) -> R

fn evaluation_is_concurrent(&self) -> bool

fn expand_abstract_consts<T: TypeFoldable<Self>>(self, t: T) -> T

fn generics_of(self, def_id: Self::DefId) -> Self::GenericsOf

fn variances_of(self, def_id: Self::DefId) -> Self::VariancesOf

fn type_of(self, def_id: Self::DefId) -> EarlyBinder<Self, Self::Ty>

fn adt_def(self, adt_def_id: Self::DefId) -> Self::AdtDef

fn alias_ty_kind(self, alias: AliasTy<Self>) -> AliasTyKind

fn alias_term_kind(self, alias: AliasTerm<Self>) -> AliasTermKind

fn trait_ref_and_own_args_for_alias( self, def_id: Self::DefId, args: Self::GenericArgs, ) -> (TraitRef<Self>, Self::GenericArgsSlice)

fn mk_args(self, args: &[Self::GenericArg]) -> Self::GenericArgs

fn mk_args_from_iter<I, T>(self, args: I) -> T::Output

where I: Iterator<Item = T>, T: CollectAndApply<Self::GenericArg, Self::GenericArgs>,

fn check_args_compatible( self, def_id: Self::DefId, args: Self::GenericArgs, ) -> bool

fn debug_assert_args_compatible( self, def_id: Self::DefId, args: Self::GenericArgs, )

fn debug_assert_existential_args_compatible( self, def_id: Self::DefId, args: Self::GenericArgs, )

Assert that the args from an ExistentialTraitRef or ExistentialProjection are compatible with the DefId.

fn mk_type_list_from_iter<I, T>(self, args: I) -> T::Output

where I: Iterator<Item = T>, T: CollectAndApply<Self::Ty, Self::Tys>,

fn parent(self, def_id: Self::DefId) -> Self::DefId

fn recursion_limit(self) -> usize

fn features(self) -> Self::Features

fn bound_coroutine_hidden_types( self, def_id: Self::DefId, ) -> impl IntoIterator<Item = EarlyBinder<Self, Binder<Self, Self::Ty>>>

fn fn_sig( self, def_id: Self::DefId, ) -> EarlyBinder<Self, Binder<Self, FnSig<Self>>>

fn coroutine_movability(self, def_id: Self::DefId) -> Movability

fn coroutine_for_closure(self, def_id: Self::DefId) -> Self::DefId

fn generics_require_sized_self(self, def_id: Self::DefId) -> bool

fn item_bounds( self, def_id: Self::DefId, ) -> EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>>

fn predicates_of( self, def_id: Self::DefId, ) -> EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>>

fn own_predicates_of( self, def_id: Self::DefId, ) -> EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>>

fn explicit_super_predicates_of( self, def_id: Self::DefId, ) -> EarlyBinder<Self, impl IntoIterator<Item = (Self::Clause, Self::Span)>>

fn explicit_implied_predicates_of( self, def_id: Self::DefId, ) -> EarlyBinder<Self, impl IntoIterator<Item = (Self::Clause, Self::Span)>>

fn impl_is_const(self, def_id: Self::DefId) -> bool

fn fn_is_const(self, def_id: Self::DefId) -> bool

fn alias_has_const_conditions(self, def_id: Self::DefId) -> bool

fn const_conditions( self, def_id: Self::DefId, ) -> EarlyBinder<Self, impl IntoIterator<Item = Binder<Self, TraitRef<Self>>>>

fn explicit_implied_const_bounds( self, def_id: Self::DefId, ) -> EarlyBinder<Self, impl IntoIterator<Item = Binder<Self, TraitRef<Self>>>>

fn has_target_features(self, def_id: Self::DefId) -> bool

fn require_lang_item(self, lang_item: TraitSolverLangItem) -> Self::DefId

fn is_lang_item( self, def_id: Self::DefId, lang_item: TraitSolverLangItem, ) -> bool

fn as_lang_item(self, def_id: Self::DefId) -> Option<TraitSolverLangItem>

fn associated_type_def_ids( self, def_id: Self::DefId, ) -> impl IntoIterator<Item = Self::DefId>

fn for_each_relevant_impl( self, trait_def_id: Self::DefId, self_ty: Self::Ty, f: impl FnMut(Self::DefId), )

fn has_item_definition(self, def_id: Self::DefId) -> bool

fn impl_is_default(self, impl_def_id: Self::DefId) -> bool

fn impl_trait_ref( self, impl_def_id: Self::DefId, ) -> EarlyBinder<Self, TraitRef<Self>>

fn impl_polarity(self, impl_def_id: Self::DefId) -> ImplPolarity

fn trait_is_auto(self, trait_def_id: Self::DefId) -> bool

fn trait_is_alias(self, trait_def_id: Self::DefId) -> bool

fn trait_is_dyn_compatible(self, trait_def_id: Self::DefId) -> bool

fn trait_is_fundamental(self, def_id: Self::DefId) -> bool

fn trait_may_be_implemented_via_object(self, trait_def_id: Self::DefId) -> bool

fn is_impl_trait_in_trait(self, def_id: Self::DefId) -> bool

fn delay_bug(self, msg: impl ToString) -> Self::ErrorGuaranteed

fn is_general_coroutine(self, coroutine_def_id: Self::DefId) -> bool

fn coroutine_is_async(self, coroutine_def_id: Self::DefId) -> bool

fn coroutine_is_gen(self, coroutine_def_id: Self::DefId) -> bool

fn coroutine_is_async_gen(self, coroutine_def_id: Self::DefId) -> bool

fn unsizing_params_for_adt( self, adt_def_id: Self::DefId, ) -> Self::UnsizingParams

fn find_const_ty_from_env( self, param_env: Self::ParamEnv, placeholder: Self::PlaceholderConst, ) -> Self::Ty

fn anonymize_bound_vars<T: TypeFoldable<Self>>( self, binder: Binder<Self, T>, ) -> Binder<Self, T>

fn opaque_types_defined_by( self, defining_anchor: Self::LocalDefId, ) -> Self::DefiningOpaqueTypes

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors