Trait rustc_infer::infer::canonical::ir::Interner

pub trait Interner: Sized + Copy + IrPrint<AliasTy<Self>> + IrPrint<AliasTerm<Self>> + IrPrint<TraitRef<Self>> + IrPrint<TraitPredicate<Self>> + IrPrint<ExistentialTraitRef<Self>> + IrPrint<ExistentialProjection<Self>> + IrPrint<ProjectionPredicate<Self>> + IrPrint<NormalizesTo<Self>> + IrPrint<SubtypePredicate<Self>> + IrPrint<CoercePredicate<Self>> + IrPrint<FnSig<Self>> {
    type DefId: Copy + Debug + Hash + Eq;
    type AdtDef: Copy + Debug + Hash + Eq;
    type GenericArgs: GenericArgs<Self>;
    type OwnItemArgs: Copy + Debug + Hash + Eq;
    type GenericArg: Copy + DebugWithInfcx<Self> + Hash + Eq + IntoKind<Kind = GenericArgKind<Self>>;
    type Term: Copy + Debug + Hash + Eq;
    type Binder<T: TypeVisitable<Self>>: BoundVars<Self> + TypeSuperVisitable<Self>;
    type BoundVars: IntoIterator<Item = Self::BoundVar>;
    type BoundVar;
    type CanonicalVars: Copy + Debug + Hash + Eq + IntoIterator<Item = CanonicalVarInfo<Self>>;
    type PredefinedOpaques: Copy + Debug + Hash + Eq;
    type DefiningOpaqueTypes: Copy + Debug + Hash + Default + Eq + TypeVisitable<Self>;
    type ExternalConstraints: Copy + Debug + Hash + Eq;
    type GoalEvaluationSteps: Copy + Debug + Hash + Eq + Deref<Target = [GoalEvaluationStep<Self>]>;
    type Ty: Ty<Self>;
    type Tys: Tys<Self>;
    type FnInputTys: Copy + Debug + Hash + Eq + Deref<Target = [Self::Ty]>;
    type ParamTy: Copy + Debug + Hash + Eq;
    type BoundTy: Copy + Debug + Hash + Eq + BoundVarLike<Self>;
    type PlaceholderTy: PlaceholderLike;
    type ErrorGuaranteed: Copy + Debug + Hash + Eq;
    type BoundExistentialPredicates: Copy + DebugWithInfcx<Self> + Hash + Eq;
    type PolyFnSig: Copy + DebugWithInfcx<Self> + Hash + Eq;
    type AllocId: Copy + Debug + Hash + Eq;
    type Pat: Copy + Debug + Hash + Eq + DebugWithInfcx<Self>;
    type Safety: Safety<Self>;
    type Abi: Abi<Self>;
    type Const: Const<Self>;
    type AliasConst: Copy + DebugWithInfcx<Self> + Hash + Eq;
    type PlaceholderConst: PlaceholderLike;
    type ParamConst: Copy + Debug + Hash + Eq;
    type BoundConst: Copy + Debug + Hash + Eq + BoundVarLike<Self>;
    type ValueConst: Copy + Debug + Hash + Eq;
    type ExprConst: Copy + DebugWithInfcx<Self> + Hash + Eq;
    type Region: Region<Self>;
    type EarlyParamRegion: Copy + Debug + Hash + Eq;
    type LateParamRegion: Copy + Debug + Hash + Eq;
    type BoundRegion: Copy + Debug + Hash + Eq + BoundVarLike<Self>;
    type InferRegion: Copy + DebugWithInfcx<Self> + Hash + Eq;
    type PlaceholderRegion: PlaceholderLike;
    type ParamEnv: Copy + Debug + Hash + Eq;
    type Predicate: Predicate<Self>;
    type TraitPredicate: Copy + Debug + Hash + Eq;
    type RegionOutlivesPredicate: Copy + Debug + Hash + Eq;
    type TypeOutlivesPredicate: Copy + Debug + Hash + Eq;
    type ProjectionPredicate: Copy + Debug + Hash + Eq;
    type NormalizesTo: Copy + Debug + Hash + Eq;
    type SubtypePredicate: Copy + Debug + Hash + Eq;
    type CoercePredicate: Copy + Debug + Hash + Eq;
    type ClosureKind: Copy + Debug + Hash + Eq;
    type Clauses: Copy + Debug + Hash + Eq + TypeSuperVisitable<Self> + Flags;
    type GenericsOf: GenericsOf<Self>;

    // Required methods
    fn mk_canonical_var_infos(
        self,
        infos: &[CanonicalVarInfo<Self>]
    ) -> Self::CanonicalVars;
    fn generics_of(self, def_id: Self::DefId) -> Self::GenericsOf;
    fn type_of_instantiated(
        self,
        def_id: Self::DefId,
        args: Self::GenericArgs
    ) -> Self::Ty;
    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::OwnItemArgs);
    fn mk_args(self, args: &[Self::GenericArg]) -> Self::GenericArgs;
    fn mk_args_from_iter(
        self,
        args: impl Iterator<Item = Self::GenericArg>
    ) -> Self::GenericArgs;
    fn check_and_mk_args(
        self,
        def_id: Self::DefId,
        args: impl IntoIterator>
    ) -> Self::GenericArgs
       where <impl IntoIterator as IntoIterator>::Item: Into<Self::GenericArg>;
    fn parent(self, def_id: Self::DefId) -> Self::DefId;
    fn recursion_limit(self) -> usize;
}

Required Associated Types

type DefId: Copy + Debug + Hash + Eq

type AdtDef: Copy + Debug + Hash + Eq

type GenericArgs: GenericArgs<Self>

type OwnItemArgs: Copy + Debug + Hash + Eq

The slice of args for a specific item. For a GAT like type Foo<'a>, it will be ['a], not including the args from the parent item (trait or impl).

type GenericArg: Copy + DebugWithInfcx<Self> + Hash + Eq + IntoKind<Kind = GenericArgKind<Self>>

type Term: Copy + Debug + Hash + Eq

type Binder<T: TypeVisitable<Self>>: BoundVars<Self> + TypeSuperVisitable<Self>

type BoundVars: IntoIterator<Item = Self::BoundVar>

type BoundVar

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

type PredefinedOpaques: Copy + Debug + Hash + Eq

type DefiningOpaqueTypes: Copy + Debug + Hash + Default + Eq + TypeVisitable<Self>

type ExternalConstraints: Copy + Debug + Hash + Eq

type GoalEvaluationSteps: Copy + Debug + Hash + Eq + Deref<Target = [GoalEvaluationStep<Self>]>

type Ty: Ty<Self>

type Tys: Tys<Self>

type FnInputTys: Copy + Debug + Hash + Eq + Deref<Target = [Self::Ty]>

type ParamTy: Copy + Debug + Hash + Eq

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

type PlaceholderTy: PlaceholderLike

type ErrorGuaranteed: Copy + Debug + Hash + Eq

type BoundExistentialPredicates: Copy + DebugWithInfcx<Self> + Hash + Eq

type PolyFnSig: Copy + DebugWithInfcx<Self> + Hash + Eq

type AllocId: Copy + Debug + Hash + Eq

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

type Safety: Safety<Self>

type Abi: Abi<Self>

type Const: Const<Self>

type AliasConst: Copy + DebugWithInfcx<Self> + Hash + Eq

type PlaceholderConst: PlaceholderLike

type ParamConst: Copy + Debug + Hash + Eq

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

type ValueConst: Copy + Debug + Hash + Eq

type ExprConst: Copy + DebugWithInfcx<Self> + Hash + Eq

type Region: Region<Self>

type EarlyParamRegion: Copy + Debug + Hash + Eq

type LateParamRegion: Copy + Debug + Hash + Eq

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

type InferRegion: Copy + DebugWithInfcx<Self> + Hash + Eq

type PlaceholderRegion: PlaceholderLike

type ParamEnv: Copy + Debug + Hash + Eq

type Predicate: Predicate<Self>

type TraitPredicate: Copy + Debug + Hash + Eq

type RegionOutlivesPredicate: Copy + Debug + Hash + Eq

type TypeOutlivesPredicate: Copy + Debug + Hash + Eq

type ProjectionPredicate: Copy + Debug + Hash + Eq

type NormalizesTo: Copy + Debug + Hash + Eq

type SubtypePredicate: Copy + Debug + Hash + Eq

type CoercePredicate: Copy + Debug + Hash + Eq

type ClosureKind: Copy + Debug + Hash + Eq

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

type GenericsOf: GenericsOf<Self>

Required Methods

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

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

fn type_of_instantiated( self, def_id: Self::DefId, args: Self::GenericArgs ) -> Self::Ty

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::OwnItemArgs)

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

fn mk_args_from_iter( self, args: impl Iterator<Item = Self::GenericArg> ) -> Self::GenericArgs

fn check_and_mk_args( self, def_id: Self::DefId, args: impl IntoIterator> ) -> Self::GenericArgs

where <impl IntoIterator as IntoIterator>::Item: Into<Self::GenericArg>,

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

fn recursion_limit(self) -> usize

Object Safety

This trait is not object safe.

Implementations on Foreign Types

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

type DefId = DefId

type AdtDef = AdtDef<'tcx>

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

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

type GenericArg = GenericArg<'tcx>

type Term = Term<'tcx>

type Binder<T: TypeVisitable<TyCtxt<'tcx>>> = Binder<'tcx, T>

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

type BoundVar = BoundVariableKind

type CanonicalVars = &'tcx RawList<(), CanonicalVarInfo<TyCtxt<'tcx>>>

type PredefinedOpaques = PredefinedOpaques<'tcx>

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

type ExternalConstraints = ExternalConstraints<'tcx>

type GoalEvaluationSteps = &'tcx [GoalEvaluationStep<TyCtxt<'tcx>>]

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<'tcx, ExistentialPredicate<TyCtxt<'tcx>>>>

type PolyFnSig = Binder<'tcx, FnSig<TyCtxt<'tcx>>>

type AllocId = AllocId

type Pat = Pattern<'tcx>

type Safety = Safety

type Abi = Abi

type Const = Const<'tcx>

type AliasConst = UnevaluatedConst<TyCtxt<'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 InferRegion = RegionVid

type PlaceholderRegion = Placeholder<BoundRegion>

type ParamEnv = ParamEnv<'tcx>

type Predicate = Predicate<'tcx>

type TraitPredicate = TraitPredicate<TyCtxt<'tcx>>

type RegionOutlivesPredicate = OutlivesPredicate<Region<'tcx>, Region<'tcx>>

type TypeOutlivesPredicate = OutlivesPredicate<Ty<'tcx>, Region<'tcx>>

type ProjectionPredicate = ProjectionPredicate<TyCtxt<'tcx>>

type NormalizesTo = NormalizesTo<TyCtxt<'tcx>>

type SubtypePredicate = SubtypePredicate<TyCtxt<'tcx>>

type CoercePredicate = CoercePredicate<TyCtxt<'tcx>>

type ClosureKind = ClosureKind

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

fn mk_canonical_var_infos( self, infos: &[CanonicalVarInfo<TyCtxt<'tcx>>] ) -> &'tcx RawList<(), CanonicalVarInfo<TyCtxt<'tcx>>>

type GenericsOf = &'tcx Generics

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

fn type_of_instantiated( self, def_id: DefId, args: &'tcx RawList<(), GenericArg<'tcx>> ) -> Ty<'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( self, args: impl Iterator<Item = GenericArg<'tcx>> ) -> &'tcx RawList<(), GenericArg<'tcx>>

fn check_and_mk_args( self, def_id: DefId, args: impl IntoIterator>> ) -> &'tcx RawList<(), GenericArg<'tcx>>

where <impl IntoIterator as IntoIterator>::Item: Into<GenericArg<'tcx>>,

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

fn recursion_limit(self) -> usize

Implementors