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>(
        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 evaluation_is_concurrent(&self) -> bool;
    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 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 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 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 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>(self, binder: Binder<Self, T>) -> Binder<Self, T>
       where T: TypeFoldable<Self>;
    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>( 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 evaluation_is_concurrent(&self) -> bool

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 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 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 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 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>(self, binder: Binder<Self, T>) -> Binder<Self, T>

where T: TypeFoldable<Self>,

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.

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

type BoundVarKind = BoundVariableKind

type PredefinedOpaques = PredefinedOpaques<'tcx>

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

type CanonicalVars = &'tcx RawList<(), CanonicalVarInfo<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 BoundTy = BoundTy

type PlaceholderTy = Placeholder<BoundTy>

type ErrorGuaranteed = ErrorGuaranteed

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

type AllocId = AllocId

type Pat = Pattern<'tcx>

type Safety = Safety

type Abi = ExternAbi

type Const = Const<'tcx>

type PlaceholderConst = Placeholder<BoundVar>

type ParamConst = ParamConst

type BoundConst = BoundVar

type ValueConst = ValTree<'tcx>

type ExprConst = Expr<'tcx>

type Region = Region<'tcx>

type EarlyParamRegion = EarlyParamRegion

type LateParamRegion = LateParamRegion

type BoundRegion = BoundRegion

type PlaceholderRegion = Placeholder<BoundRegion>

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 BitSet<u32>

fn mk_predefined_opaques_in_body( self, data: PredefinedOpaquesData<TyCtxt<'tcx>>, ) -> PredefinedOpaques<'tcx>

fn mk_canonical_var_infos( self, infos: &[CanonicalVarInfo<TyCtxt<'tcx>>], ) -> &'tcx RawList<(), CanonicalVarInfo<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 evaluation_is_concurrent(&self) -> bool

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 type_of(self, def_id: DefId) -> EarlyBinder<TyCtxt<'tcx>, Ty<'tcx>>

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

fn alias_ty_kind(self, alias: AliasTy<TyCtxt<'tcx>>) -> AliasTyKind

fn alias_term_kind(self, alias: AliasTerm<TyCtxt<'tcx>>) -> AliasTermKind

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 parent(self, def_id: DefId) -> DefId

fn recursion_limit(self) -> usize

fn features(self) -> &'tcx Features

fn bound_coroutine_hidden_types( self, def_id: DefId, ) -> impl IntoIterator<Item = EarlyBinder<TyCtxt<'tcx>, Binder<TyCtxt<'tcx>, Ty<'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 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_is_const(self, def_id: DefId) -> bool

fn fn_is_const(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 has_target_features(self, def_id: DefId) -> bool

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

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

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

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

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

fn has_item_definition(self, 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_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_may_be_implemented_via_object(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 BitSet<u32>

fn find_const_ty_from_env( self, param_env: ParamEnv<'tcx>, placeholder: Placeholder<BoundVar>, ) -> Ty<'tcx>

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>

Implementors