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>>
    + IrPrint<PatternKind<Self>> {
    type DefId: DefId<Self>;
    type LocalDefId: Copy + Debug + Hash + Eq + Into<Self::DefId> + TypeFoldable<Self>;
    type TraitId: SpecificDefId<Self>;
    type ForeignId: SpecificDefId<Self>;
    type FunctionId: SpecificDefId<Self>;
    type ClosureId: SpecificDefId<Self>;
    type CoroutineClosureId: SpecificDefId<Self>;
    type CoroutineId: SpecificDefId<Self>;
    type AdtId: SpecificDefId<Self>;
    type ImplId: SpecificDefId<Self>;
    type UnevaluatedConstId: SpecificDefId<Self>;
    type TraitAssocTyId: SpecificDefId<Self> + Into<Self::TraitAssocTermId> + TryFrom<Self::TraitAssocTermId>;
    type TraitAssocConstId: SpecificDefId<Self> + Into<Self::TraitAssocTermId> + Into<Self::UnevaluatedConstId> + TryFrom<Self::TraitAssocTermId>;
    type TraitAssocTermId: SpecificDefId<Self>;
    type OpaqueTyId: SpecificDefId<Self, Self::LocalOpaqueTyId>;
    type LocalOpaqueTyId: Copy + Debug + Hash + Eq + Into<Self::OpaqueTyId> + Into<Self::LocalDefId> + Into<Self::DefId> + TypeFoldable<Self>;
    type FreeTyAliasId: SpecificDefId<Self> + Into<Self::FreeTermAliasId>;
    type FreeConstAliasId: SpecificDefId<Self> + Into<Self::UnevaluatedConstId> + Into<Self::FreeTermAliasId>;
    type FreeTermAliasId: SpecificDefId<Self>;
    type ImplOrTraitAssocTyId: SpecificDefId<Self> + Into<Self::ImplOrTraitAssocTermId>;
    type ImplOrTraitAssocConstId: SpecificDefId<Self> + Into<Self::UnevaluatedConstId> + Into<Self::ImplOrTraitAssocTermId>;
    type ImplOrTraitAssocTermId: SpecificDefId<Self>;
    type InherentAssocTyId: SpecificDefId<Self> + Into<Self::InherentAssocTermId>;
    type InherentAssocConstId: SpecificDefId<Self> + Into<Self::UnevaluatedConstId> + Into<Self::InherentAssocTermId>;
    type InherentAssocTermId: SpecificDefId<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: BoundVarKinds<Self>;
    type PredefinedOpaques: Copy + Debug + Hash + Eq + TypeFoldable<Self> + SliceLike<Item = (OpaqueTypeKey<Self>, Self::Ty)>;
    type LocalDefIds: Copy + Debug + Hash + Default + Eq + TypeVisitable<Self> + SliceLike<Item = Self::LocalDefId>;
    type CanonicalVarKinds: Copy + Debug + Hash + Eq + SliceLike<Item = CanonicalVarKind<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: ParamLike;
    type Symbol: Symbol<Self>;
    type ErrorGuaranteed: Copy + Debug + Hash + Eq;
    type BoundExistentialPredicates: BoundExistentialPredicates<Self>;
    type AllocId: Copy + Debug + Hash + Eq;
    type Pat: Copy + Debug + Hash + Eq + Relate<Self> + Flags + IntoKind<Kind = PatternKind<Self>>;
    type PatList: Copy + Debug + Hash + Default + Eq + TypeVisitable<Self> + SliceLike<Item = Self::Pat>;
    type Safety: Safety<Self>;
    type Const: Const<Self>;
    type Consts: Copy + Debug + Hash + Eq + SliceLike<Item = Self::Const> + Default;
    type ParamConst: Copy + Debug + Hash + Eq + ParamLike;
    type ValueConst: ValueConst<Self>;
    type ExprConst: ExprConst<Self>;
    type ValTree: Copy + Debug + Hash + Eq + IntoKind<Kind = ValTreeKind<Self>>;
    type ScalarInt: Copy + Debug + Hash + Eq;
    type Region: Region<Self>;
    type EarlyParamRegion: ParamLike;
    type LateParamRegion: Copy + Debug + Hash + Eq;
    type RegionAssumptions: Copy + Debug + Hash + Eq + SliceLike<Item = OutlivesPredicate<Self, Self::GenericArg>> + TypeFoldable<Self>;
    type ParamEnv: ParamEnv<Self>;
    type Predicate: Predicate<Self>;
    type Clause: Clause<Self>;
    type Clauses: Clauses<Self>;
    type GenericsOf: GenericsOf<Self>;
    type VariancesOf: Copy + Debug + SliceLike<Item = Variance>;
    type AdtDef: AdtDef<Self>;
    type Features: Features<Self>;
    type UnsizingParams: Deref<Target = DenseBitSet<u32>>;
    type Probe: Debug + Hash + Eq + Borrow<Probe<Self>>;

    // Required methods
    fn mk_predefined_opaques_in_body(
        self,
        data: &[(OpaqueTypeKey<Self>, Self::Ty)],
    ) -> Self::PredefinedOpaques;
    fn mk_canonical_var_kinds(
        self,
        kinds: &[CanonicalVarKind<Self>],
    ) -> Self::CanonicalVarKinds;
    fn mk_external_constraints(
        self,
        data: ExternalConstraintsData<Self>,
    ) -> Self::ExternalConstraints;
    fn mk_tracked<T>(
        self,
        data: T,
        dep_node: Self::DepNodeIndex,
    ) -> Self::Tracked<T>
       where T: Debug + Clone;
    fn get_tracked<T>(self, tracked: &Self::Tracked<T>) -> T
       where T: Debug + Clone;
    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 canonical_param_env_cache_get_or_insert<R>(
        self,
        param_env: Self::ParamEnv,
        f: impl FnOnce() -> CanonicalParamEnvCacheEntry<Self>,
        from_entry: impl FnOnce(&CanonicalParamEnvCacheEntry<Self>) -> R,
    ) -> R;
    fn assert_evaluation_is_concurrent(&self);
    fn expand_abstract_consts<T>(self, t: T) -> T
       where T: TypeFoldable<Self>;
    fn generics_of(self, def_id: Self::DefId) -> Self::GenericsOf;
    fn variances_of(self, def_id: Self::DefId) -> Self::VariancesOf;
    fn opt_alias_variances(
        self,
        kind: impl Into<AliasTermKind<Self>>,
    ) -> Option<Self::VariancesOf>;
    fn type_of(self, def_id: Self::DefId) -> EarlyBinder<Self, Self::Ty>;
    fn type_of_opaque_hir_typeck(
        self,
        def_id: Self::LocalOpaqueTyId,
    ) -> EarlyBinder<Self, Self::Ty>;
    fn is_type_const(self, def_id: Self::DefId) -> bool;
    fn const_of_item(
        self,
        def_id: Self::DefId,
    ) -> EarlyBinder<Self, Self::Const>;
    fn anon_const_kind(self, def_id: Self::DefId) -> AnonConstKind;
    fn adt_def(self, adt_def_id: Self::AdtId) -> Self::AdtDef;
    fn alias_ty_kind_from_def_id(self, def_id: Self::DefId) -> AliasTyKind<Self>;
    fn alias_term_kind_from_def_id(
        self,
        def_id: Self::DefId,
    ) -> AliasTermKind<Self>;
    fn trait_ref_and_own_args_for_alias(
        self,
        def_id: Self::TraitAssocTermId,
        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 as CollectAndApply<Self::GenericArg, Self::GenericArgs>>::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 as CollectAndApply<Self::Ty, Self::Tys>>::Output
       where I: Iterator<Item = T>,
             T: CollectAndApply<Self::Ty, Self::Tys>;
    fn projection_parent(self, def_id: Self::TraitAssocTermId) -> Self::TraitId;
    fn impl_or_trait_assoc_term_parent(
        self,
        def_id: Self::ImplOrTraitAssocTermId,
    ) -> Self::DefId;
    fn inherent_alias_term_parent(
        self,
        def_id: Self::InherentAssocTermId,
    ) -> Self::ImplId;
    fn recursion_limit(self) -> usize;
    fn features(self) -> Self::Features;
    fn assumptions_on_binders(self) -> bool;
    fn coroutine_hidden_types(
        self,
        def_id: Self::CoroutineId,
    ) -> EarlyBinder<Self, Binder<Self, CoroutineWitnessTypes<Self>>>;
    fn fn_sig(
        self,
        def_id: Self::FunctionId,
    ) -> EarlyBinder<Self, Binder<Self, FnSig<Self>>>;
    fn coroutine_movability(self, def_id: Self::CoroutineId) -> Movability;
    fn coroutine_for_closure(
        self,
        def_id: Self::CoroutineClosureId,
    ) -> Self::CoroutineId;
    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 item_self_bounds(
        self,
        def_id: Self::DefId,
    ) -> EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>>;
    fn item_non_self_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::TraitId,
    ) -> 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_super_outlives(
        self,
        impl_def_id: Self::ImplId,
    ) -> EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>>;
    fn impl_is_const(self, def_id: Self::ImplId) -> bool;
    fn fn_is_const(self, def_id: Self::FunctionId) -> bool;
    fn closure_is_const(self, def_id: Self::ClosureId) -> 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 impl_self_is_guaranteed_unsized(self, def_id: Self::ImplId) -> bool;
    fn has_target_features(self, def_id: Self::FunctionId) -> bool;
    fn require_projection_lang_item(
        self,
        lang_item: SolverProjectionLangItem,
    ) -> Self::TraitAssocTyId;
    fn require_trait_lang_item(
        self,
        lang_item: SolverTraitLangItem,
    ) -> Self::TraitId;
    fn require_adt_lang_item(self, lang_item: SolverAdtLangItem) -> Self::AdtId;
    fn is_projection_lang_item(
        self,
        def_id: Self::TraitAssocTyId,
        lang_item: SolverProjectionLangItem,
    ) -> bool;
    fn is_trait_lang_item(
        self,
        def_id: Self::TraitId,
        lang_item: SolverTraitLangItem,
    ) -> bool;
    fn is_adt_lang_item(
        self,
        def_id: Self::AdtId,
        lang_item: SolverAdtLangItem,
    ) -> bool;
    fn is_default_trait(self, def_id: Self::TraitId) -> bool;
    fn is_sizedness_trait(self, def_id: Self::TraitId) -> bool;
    fn as_projection_lang_item(
        self,
        def_id: Self::TraitAssocTyId,
    ) -> Option<SolverProjectionLangItem>;
    fn as_trait_lang_item(
        self,
        def_id: Self::TraitId,
    ) -> Option<SolverTraitLangItem>;
    fn as_adt_lang_item(self, def_id: Self::AdtId) -> Option<SolverAdtLangItem>;
    fn associated_type_def_ids(
        self,
        def_id: Self::TraitId,
    ) -> impl IntoIterator<Item = Self::DefId>;
    fn for_each_relevant_impl<R>(
        self,
        trait_def_id: Self::TraitId,
        self_ty: Self::Ty,
        f: impl FnMut(Self::ImplId) -> R,
    ) -> R
       where R: VisitorResult;
    fn for_each_blanket_impl<R>(
        self,
        trait_def_id: Self::TraitId,
        f: impl FnMut(Self::ImplId) -> R,
    ) -> R
       where R: VisitorResult;
    fn has_item_definition(self, def_id: Self::ImplOrTraitAssocTermId) -> bool;
    fn impl_specializes(
        self,
        impl_def_id: Self::ImplId,
        victim_def_id: Self::ImplId,
    ) -> bool;
    fn impl_is_default(self, impl_def_id: Self::ImplId) -> bool;
    fn impl_trait_ref(
        self,
        impl_def_id: Self::ImplId,
    ) -> EarlyBinder<Self, TraitRef<Self>>;
    fn impl_polarity(self, impl_def_id: Self::ImplId) -> ImplPolarity;
    fn trait_is_auto(self, trait_def_id: Self::TraitId) -> bool;
    fn trait_is_coinductive(self, trait_def_id: Self::TraitId) -> bool;
    fn trait_is_alias(self, trait_def_id: Self::TraitId) -> bool;
    fn trait_is_dyn_compatible(self, trait_def_id: Self::TraitId) -> bool;
    fn trait_is_fundamental(self, def_id: Self::TraitId) -> bool;
    fn trait_is_unsafe(self, trait_def_id: Self::TraitId) -> 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::CoroutineId) -> bool;
    fn coroutine_is_async(self, coroutine_def_id: Self::CoroutineId) -> bool;
    fn coroutine_is_gen(self, coroutine_def_id: Self::CoroutineId) -> bool;
    fn coroutine_is_async_gen(self, coroutine_def_id: Self::CoroutineId) -> bool;
    fn unsizing_params_for_adt(
        self,
        adt_def_id: Self::AdtId,
    ) -> Self::UnsizingParams;
    fn anonymize_bound_vars<T>(self, binder: Binder<Self, T>) -> Binder<Self, T>
       where T: TypeFoldable<Self>;
    fn opaque_types_defined_by(
        self,
        defining_anchor: Self::LocalDefId,
    ) -> Self::LocalDefIds;
    fn opaque_types_and_coroutines_defined_by(
        self,
        defining_anchor: Self::LocalDefId,
    ) -> Self::LocalDefIds;
    fn mk_probe(self, probe: Probe<Self>) -> Self::Probe;
    fn evaluate_root_goal_for_proof_tree_raw(
        self,
        canonical_goal: CanonicalQueryInput<Self, QueryInput<Self, Self::Predicate>>,
    ) -> (Result<Canonical<Self, Response<Self>>, NoSolution>, Self::Probe);
    fn item_name(self, item_index: Self::DefId) -> Self::Symbol;

    // Provided method
    fn next_trait_solver_globally(self) -> bool { ... }
}

Required Associated Types

type DefId: DefId<Self>

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

type TraitId: SpecificDefId<Self>

type ForeignId: SpecificDefId<Self>

type FunctionId: SpecificDefId<Self>

type ClosureId: SpecificDefId<Self>

type CoroutineClosureId: SpecificDefId<Self>

type CoroutineId: SpecificDefId<Self>

type AdtId: SpecificDefId<Self>

type ImplId: SpecificDefId<Self>

type UnevaluatedConstId: SpecificDefId<Self>

type TraitAssocTyId: SpecificDefId<Self> + Into<Self::TraitAssocTermId> + TryFrom<Self::TraitAssocTermId>

type TraitAssocConstId: SpecificDefId<Self> + Into<Self::TraitAssocTermId> + Into<Self::UnevaluatedConstId> + TryFrom<Self::TraitAssocTermId>

type TraitAssocTermId: SpecificDefId<Self>

type OpaqueTyId: SpecificDefId<Self, Self::LocalOpaqueTyId>

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

type FreeTyAliasId: SpecificDefId<Self> + Into<Self::FreeTermAliasId>

type FreeConstAliasId: SpecificDefId<Self> + Into<Self::UnevaluatedConstId> + Into<Self::FreeTermAliasId>

type FreeTermAliasId: SpecificDefId<Self>

type ImplOrTraitAssocTyId: SpecificDefId<Self> + Into<Self::ImplOrTraitAssocTermId>

type ImplOrTraitAssocConstId: SpecificDefId<Self> + Into<Self::UnevaluatedConstId> + Into<Self::ImplOrTraitAssocTermId>

type ImplOrTraitAssocTermId: SpecificDefId<Self>

type InherentAssocTyId: SpecificDefId<Self> + Into<Self::InherentAssocTermId>

type InherentAssocConstId: SpecificDefId<Self> + Into<Self::UnevaluatedConstId> + Into<Self::InherentAssocTermId>

type InherentAssocTermId: SpecificDefId<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: BoundVarKinds<Self>

type PredefinedOpaques: Copy + Debug + Hash + Eq + TypeFoldable<Self> + SliceLike<Item = (OpaqueTypeKey<Self>, Self::Ty)>

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

type CanonicalVarKinds: Copy + Debug + Hash + Eq + SliceLike<Item = CanonicalVarKind<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: ParamLike

type Symbol: Symbol<Self>

type ErrorGuaranteed: Copy + Debug + Hash + Eq

type BoundExistentialPredicates: BoundExistentialPredicates<Self>

type AllocId: Copy + Debug + Hash + Eq

type Pat: Copy + Debug + Hash + Eq + Relate<Self> + Flags + IntoKind<Kind = PatternKind<Self>>

type PatList: Copy + Debug + Hash + Default + Eq + TypeVisitable<Self> + SliceLike<Item = Self::Pat>

type Safety: Safety<Self>

type Const: Const<Self>

type Consts: Copy + Debug + Hash + Eq + SliceLike<Item = Self::Const> + Default

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

type ValueConst: ValueConst<Self>

type ExprConst: ExprConst<Self>

type ValTree: Copy + Debug + Hash + Eq + IntoKind<Kind = ValTreeKind<Self>>

type ScalarInt: Copy + Debug + Hash + Eq

type Region: Region<Self>

type EarlyParamRegion: ParamLike

type LateParamRegion: Copy + Debug + Hash + Eq

type RegionAssumptions: Copy + Debug + Hash + Eq + SliceLike<Item = OutlivesPredicate<Self, Self::GenericArg>> + TypeFoldable<Self>

type ParamEnv: ParamEnv<Self>

type Predicate: Predicate<Self>

type Clause: Clause<Self>

type Clauses: Clauses<Self>

type GenericsOf: GenericsOf<Self>

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

type AdtDef: AdtDef<Self>

type Features: Features<Self>

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

type Probe: Debug + Hash + Eq + Borrow<Probe<Self>>

Required Methods

fn mk_predefined_opaques_in_body( self, data: &[(OpaqueTypeKey<Self>, Self::Ty)], ) -> Self::PredefinedOpaques

fn mk_canonical_var_kinds( self, kinds: &[CanonicalVarKind<Self>], ) -> Self::CanonicalVarKinds

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

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

where T: Debug + Clone,

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

where T: Debug + Clone,

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 canonical_param_env_cache_get_or_insert<R>( self, param_env: Self::ParamEnv, f: impl FnOnce() -> CanonicalParamEnvCacheEntry<Self>, from_entry: impl FnOnce(&CanonicalParamEnvCacheEntry<Self>) -> R, ) -> R

fn assert_evaluation_is_concurrent(&self)

Useful for testing. If a cache entry is replaced, this should (in theory) only happen when concurrent.

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

where T: TypeFoldable<Self>,

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

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

fn opt_alias_variances( self, kind: impl Into<AliasTermKind<Self>>, ) -> Option<Self::VariancesOf>

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

fn type_of_opaque_hir_typeck( self, def_id: Self::LocalOpaqueTyId, ) -> EarlyBinder<Self, Self::Ty>

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

fn const_of_item(self, def_id: Self::DefId) -> EarlyBinder<Self, Self::Const>

fn anon_const_kind(self, def_id: Self::DefId) -> AnonConstKind

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

fn alias_ty_kind_from_def_id(self, def_id: Self::DefId) -> AliasTyKind<Self>

fn alias_term_kind_from_def_id(self, def_id: Self::DefId) -> AliasTermKind<Self>

fn trait_ref_and_own_args_for_alias( self, def_id: Self::TraitAssocTermId, 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 as CollectAndApply<Self::GenericArg, Self::GenericArgs>>::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 as CollectAndApply<Self::Ty, Self::Tys>>::Output

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

fn projection_parent(self, def_id: Self::TraitAssocTermId) -> Self::TraitId

fn impl_or_trait_assoc_term_parent( self, def_id: Self::ImplOrTraitAssocTermId, ) -> Self::DefId

This can be an impl, or a trait if this is a defaulted term.

fn inherent_alias_term_parent( self, def_id: Self::InherentAssocTermId, ) -> Self::ImplId

fn recursion_limit(self) -> usize

fn features(self) -> Self::Features

fn assumptions_on_binders(self) -> bool

fn coroutine_hidden_types( self, def_id: Self::CoroutineId, ) -> EarlyBinder<Self, Binder<Self, CoroutineWitnessTypes<Self>>>

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

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

fn coroutine_for_closure( self, def_id: Self::CoroutineClosureId, ) -> Self::CoroutineId

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 item_self_bounds( self, def_id: Self::DefId, ) -> EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>>

fn item_non_self_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::TraitId, ) -> 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_super_outlives( self, impl_def_id: Self::ImplId, ) -> EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>>

This is equivalent to computing the super-predicates of the trait for this impl and filtering them to the outlives predicates. This is purely for performance.

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

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

fn closure_is_const(self, def_id: Self::ClosureId) -> 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 impl_self_is_guaranteed_unsized(self, def_id: Self::ImplId) -> bool

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

fn require_projection_lang_item( self, lang_item: SolverProjectionLangItem, ) -> Self::TraitAssocTyId

fn require_trait_lang_item( self, lang_item: SolverTraitLangItem, ) -> Self::TraitId

fn require_adt_lang_item(self, lang_item: SolverAdtLangItem) -> Self::AdtId

fn is_projection_lang_item( self, def_id: Self::TraitAssocTyId, lang_item: SolverProjectionLangItem, ) -> bool

fn is_trait_lang_item( self, def_id: Self::TraitId, lang_item: SolverTraitLangItem, ) -> bool

fn is_adt_lang_item( self, def_id: Self::AdtId, lang_item: SolverAdtLangItem, ) -> bool

fn is_default_trait(self, def_id: Self::TraitId) -> bool

fn is_sizedness_trait(self, def_id: Self::TraitId) -> bool

fn as_projection_lang_item( self, def_id: Self::TraitAssocTyId, ) -> Option<SolverProjectionLangItem>

fn as_trait_lang_item( self, def_id: Self::TraitId, ) -> Option<SolverTraitLangItem>

fn as_adt_lang_item(self, def_id: Self::AdtId) -> Option<SolverAdtLangItem>

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

fn for_each_relevant_impl<R>( self, trait_def_id: Self::TraitId, self_ty: Self::Ty, f: impl FnMut(Self::ImplId) -> R, ) -> R

where R: VisitorResult,

fn for_each_blanket_impl<R>( self, trait_def_id: Self::TraitId, f: impl FnMut(Self::ImplId) -> R, ) -> R

where R: VisitorResult,

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

fn impl_specializes( self, impl_def_id: Self::ImplId, victim_def_id: Self::ImplId, ) -> bool

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

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

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

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

fn trait_is_coinductive(self, trait_def_id: Self::TraitId) -> bool

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

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

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

fn trait_is_unsafe(self, trait_def_id: Self::TraitId) -> bool

Returns true if this is an unsafe trait.

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::CoroutineId) -> bool

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

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

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

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

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

where T: TypeFoldable<Self>,

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

fn opaque_types_and_coroutines_defined_by( self, defining_anchor: Self::LocalDefId, ) -> Self::LocalDefIds

fn mk_probe(self, probe: Probe<Self>) -> Self::Probe

fn evaluate_root_goal_for_proof_tree_raw( self, canonical_goal: CanonicalQueryInput<Self, QueryInput<Self, Self::Predicate>>, ) -> (Result<Canonical<Self, Response<Self>>, NoSolution>, Self::Probe)

fn item_name(self, item_index: Self::DefId) -> Self::Symbol

Provided Methods

fn next_trait_solver_globally(self) -> bool

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<'tcx> Interner for TyCtxt<'tcx>

fn debug_assert_existential_args_compatible( self, def_id: DefId, args: &'tcx RawList<(), GenericArg<'tcx>>, )

Assert that the args from an ExistentialTraitRef or ExistentialProjection are compatible with the DefId. Since we’re missing a Self type, stick on a dummy self type and forward to debug_assert_args_compatible.

type DefId = DefId

type LocalDefId = LocalDefId

type TraitId = DefId

type ForeignId = DefId

type FunctionId = DefId

type ClosureId = DefId

type CoroutineClosureId = DefId

type CoroutineId = DefId

type AdtId = DefId

type ImplId = DefId

type UnevaluatedConstId = DefId

type TraitAssocTyId = DefId

type TraitAssocConstId = DefId

type TraitAssocTermId = DefId

type OpaqueTyId = DefId

type LocalOpaqueTyId = LocalDefId

type FreeTyAliasId = DefId

type FreeConstAliasId = DefId

type FreeTermAliasId = DefId

type ImplOrTraitAssocTyId = DefId

type ImplOrTraitAssocConstId = DefId

type ImplOrTraitAssocTermId = DefId

type InherentAssocTyId = DefId

type InherentAssocConstId = DefId

type InherentAssocTermId = DefId

type Span = Span

type GenericArgs = &'tcx RawList<(), GenericArg<'tcx>>

type GenericArgsSlice = &'tcx [GenericArg<'tcx>]

type GenericArg = GenericArg<'tcx>

type Term = Term<'tcx>

type BoundVarKinds = &'tcx RawList<(), BoundVariableKind<TyCtxt<'tcx>>>

type PredefinedOpaques = &'tcx RawList<(), (OpaqueTypeKey<TyCtxt<'tcx>>, Ty<'tcx>)>

type LocalDefIds = &'tcx RawList<(), LocalDefId>

type CanonicalVarKinds = &'tcx RawList<(), CanonicalVarKind<TyCtxt<'tcx>>>

type ExternalConstraints = ExternalConstraints<'tcx>

type DepNodeIndex = DepNodeIndex

type Ty = Ty<'tcx>

type Tys = &'tcx RawList<(), Ty<'tcx>>

type FnInputTys = &'tcx [Ty<'tcx>]

type ParamTy = ParamTy

type Symbol = Symbol

type ErrorGuaranteed = ErrorGuaranteed

type BoundExistentialPredicates = &'tcx RawList<(), Binder<TyCtxt<'tcx>, ExistentialPredicate<TyCtxt<'tcx>>>>

type AllocId = AllocId

type Pat = Pattern<'tcx>

type PatList = &'tcx RawList<(), Pattern<'tcx>>

type Safety = Safety

type Const = Const<'tcx>

type Consts = &'tcx RawList<(), Const<'tcx>>

type ParamConst = ParamConst

type ValueConst = Value<'tcx>

type ExprConst = Expr<'tcx>

type ValTree = ValTree<'tcx>

type ScalarInt = ScalarInt

type Region = Region<'tcx>

type EarlyParamRegion = EarlyParamRegion

type LateParamRegion = LateParamRegion

type RegionAssumptions = &'tcx RawList<(), OutlivesPredicate<TyCtxt<'tcx>, GenericArg<'tcx>>>

type ParamEnv = ParamEnv<'tcx>

type Predicate = Predicate<'tcx>

type Clause = Clause<'tcx>

type Clauses = &'tcx RawList<TypeInfo, Clause<'tcx>>

type Tracked<T: Debug + Clone> = WithDepNode<T>

type GenericsOf = &'tcx Generics

type VariancesOf = &'tcx [Variance]

type AdtDef = AdtDef<'tcx>

type Features = &'tcx Features

type UnsizingParams = &'tcx DenseBitSet<u32>

type Probe = &'tcx Probe<TyCtxt<'tcx>>

fn next_trait_solver_globally(self) -> bool

fn mk_predefined_opaques_in_body( self, data: &[(OpaqueTypeKey<TyCtxt<'tcx>>, Ty<'tcx>)], ) -> &'tcx RawList<(), (OpaqueTypeKey<TyCtxt<'tcx>>, Ty<'tcx>)>

fn mk_canonical_var_kinds( self, kinds: &[CanonicalVarKind<TyCtxt<'tcx>>], ) -> &'tcx RawList<(), CanonicalVarKind<TyCtxt<'tcx>>>

fn mk_external_constraints( self, data: ExternalConstraintsData<TyCtxt<'tcx>>, ) -> ExternalConstraints<'tcx>

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

fn mk_tracked<T>( self, data: T, dep_node: DepNodeIndex, ) -> <TyCtxt<'tcx> as Interner>::Tracked<T>

where T: Debug + Clone,

fn get_tracked<T>(self, tracked: &<TyCtxt<'tcx> as Interner>::Tracked<T>) -> T

where T: Debug + Clone,

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

fn canonical_param_env_cache_get_or_insert<R>( self, param_env: ParamEnv<'tcx>, f: impl FnOnce() -> CanonicalParamEnvCacheEntry<TyCtxt<'tcx>>, from_entry: impl FnOnce(&CanonicalParamEnvCacheEntry<TyCtxt<'tcx>>) -> R, ) -> R

fn assert_evaluation_is_concurrent(&self)

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

where T: TypeFoldable<TyCtxt<'tcx>>,

fn generics_of(self, def_id: DefId) -> &'tcx Generics

fn variances_of(self, def_id: DefId) -> &'tcx [Variance]

fn opt_alias_variances( self, kind: impl Into<AliasTermKind<TyCtxt<'tcx>>>, ) -> Option<&'tcx [Variance]>

fn type_of(self, def_id: DefId) -> EarlyBinder<TyCtxt<'tcx>, Ty<'tcx>>

fn type_of_opaque_hir_typeck( self, def_id: LocalDefId, ) -> EarlyBinder<TyCtxt<'tcx>, Ty<'tcx>>

fn is_type_const(self, def_id: DefId) -> bool

fn const_of_item(self, def_id: DefId) -> EarlyBinder<TyCtxt<'tcx>, Const<'tcx>>

fn anon_const_kind(self, def_id: DefId) -> AnonConstKind

fn adt_def(self, adt_def_id: DefId) -> AdtDef<'tcx>

fn alias_ty_kind_from_def_id(self, def_id: DefId) -> AliasTyKind<TyCtxt<'tcx>>

fn alias_term_kind_from_def_id( self, def_id: DefId, ) -> AliasTermKind<TyCtxt<'tcx>>

fn trait_ref_and_own_args_for_alias( self, def_id: DefId, args: &'tcx RawList<(), GenericArg<'tcx>>, ) -> (TraitRef<TyCtxt<'tcx>>, &'tcx [GenericArg<'tcx>])

fn mk_args( self, args: &[GenericArg<'tcx>], ) -> &'tcx RawList<(), GenericArg<'tcx>>

fn mk_args_from_iter<I, T>( self, args: I, ) -> <T as CollectAndApply<GenericArg<'tcx>, &'tcx RawList<(), GenericArg<'tcx>>>>::Output

where I: Iterator<Item = T>, T: CollectAndApply<GenericArg<'tcx>, &'tcx RawList<(), GenericArg<'tcx>>>,

fn check_args_compatible( self, def_id: DefId, args: &'tcx RawList<(), GenericArg<'tcx>>, ) -> bool

fn debug_assert_args_compatible( self, def_id: DefId, args: &'tcx RawList<(), GenericArg<'tcx>>, )

fn mk_type_list_from_iter<I, T>( self, args: I, ) -> <T as CollectAndApply<Ty<'tcx>, &'tcx RawList<(), Ty<'tcx>>>>::Output

where I: Iterator<Item = T>, T: CollectAndApply<Ty<'tcx>, &'tcx RawList<(), Ty<'tcx>>>,

fn projection_parent(self, def_id: DefId) -> DefId

fn impl_or_trait_assoc_term_parent(self, def_id: DefId) -> DefId

fn inherent_alias_term_parent(self, def_id: DefId) -> DefId

fn recursion_limit(self) -> usize

fn features(self) -> &'tcx Features

fn assumptions_on_binders(self) -> bool

fn coroutine_hidden_types( self, def_id: DefId, ) -> EarlyBinder<TyCtxt<'tcx>, Binder<TyCtxt<'tcx>, CoroutineWitnessTypes<TyCtxt<'tcx>>>>

fn fn_sig( self, def_id: DefId, ) -> EarlyBinder<TyCtxt<'tcx>, Binder<TyCtxt<'tcx>, FnSig<TyCtxt<'tcx>>>>

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

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

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

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

fn item_self_bounds( self, def_id: DefId, ) -> EarlyBinder<TyCtxt<'tcx>, impl IntoIterator<Item = Clause<'tcx>>>

fn item_non_self_bounds( self, def_id: DefId, ) -> EarlyBinder<TyCtxt<'tcx>, impl IntoIterator<Item = Clause<'tcx>>>

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

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

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

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

fn impl_super_outlives( self, impl_def_id: DefId, ) -> EarlyBinder<TyCtxt<'tcx>, impl IntoIterator<Item = Clause<'tcx>>>

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

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

fn closure_is_const(self, def_id: DefId) -> bool

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

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

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

fn impl_self_is_guaranteed_unsized(self, impl_def_id: DefId) -> bool

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

fn require_projection_lang_item( self, lang_item: SolverProjectionLangItem, ) -> DefId

fn require_trait_lang_item(self, lang_item: SolverTraitLangItem) -> DefId

fn require_adt_lang_item(self, lang_item: SolverAdtLangItem) -> DefId

fn is_projection_lang_item( self, def_id: DefId, lang_item: SolverProjectionLangItem, ) -> bool

fn is_trait_lang_item( self, def_id: DefId, lang_item: SolverTraitLangItem, ) -> bool

fn is_adt_lang_item(self, def_id: DefId, lang_item: SolverAdtLangItem) -> bool

fn is_default_trait(self, def_id: DefId) -> bool

fn is_sizedness_trait(self, def_id: DefId) -> bool

fn as_projection_lang_item( self, def_id: DefId, ) -> Option<SolverProjectionLangItem>

fn as_trait_lang_item(self, def_id: DefId) -> Option<SolverTraitLangItem>

fn as_adt_lang_item(self, def_id: DefId) -> Option<SolverAdtLangItem>

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

fn for_each_relevant_impl<R>( self, trait_def_id: DefId, self_ty: Ty<'tcx>, f: impl FnMut(DefId) -> R, ) -> R

where R: VisitorResult,

fn for_each_blanket_impl<R>( self, trait_def_id: DefId, f: impl FnMut(DefId) -> R, ) -> R

where R: VisitorResult,

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

fn impl_specializes(self, impl_def_id: DefId, victim_def_id: DefId) -> bool

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

fn impl_trait_ref( self, impl_def_id: DefId, ) -> EarlyBinder<TyCtxt<'tcx>, TraitRef<TyCtxt<'tcx>>>

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

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

fn trait_is_coinductive(self, trait_def_id: DefId) -> bool

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

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

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

fn trait_is_unsafe(self, trait_def_id: DefId) -> bool

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

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

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

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

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

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

fn unsizing_params_for_adt(self, adt_def_id: DefId) -> &'tcx DenseBitSet<u32>

fn anonymize_bound_vars<T>( self, binder: Binder<TyCtxt<'tcx>, T>, ) -> Binder<TyCtxt<'tcx>, T>

where T: TypeFoldable<TyCtxt<'tcx>>,

fn opaque_types_defined_by( self, defining_anchor: LocalDefId, ) -> &'tcx RawList<(), LocalDefId>

fn opaque_types_and_coroutines_defined_by( self, defining_anchor: LocalDefId, ) -> &'tcx RawList<(), LocalDefId>

fn mk_probe(self, probe: Probe<TyCtxt<'tcx>>) -> &'tcx Probe<TyCtxt<'tcx>>

fn evaluate_root_goal_for_proof_tree_raw( self, canonical_goal: CanonicalQueryInput<TyCtxt<'tcx>, QueryInput<TyCtxt<'tcx>, Predicate<'tcx>>>, ) -> (Result<Canonical<TyCtxt<'tcx>, Response<TyCtxt<'tcx>>>, NoSolution>, &'tcx Probe<TyCtxt<'tcx>>)

fn item_name(self, id: DefId) -> Symbol

Implementors