Struct DbInterner 

pub struct DbInterner<'db> { /* private fields */ }

Implementations

impl<'db> DbInterner<'db>

pub fn instantiate_bound_regions<T, F>( self, value: Binder<DbInterner<'db>, T>, fld_r: F, ) -> (T, IndexMap<BoundRegion, Region<'db>, BuildHasherDefault<FxHasher>>)

where F: FnMut(BoundRegion) -> Region<'db>, T: TypeFoldable<DbInterner<'db>>,

Replaces all regions bound by the given Binder with the results returned by the closure; the closure is expected to return a free region (relative to this binder), and hence the binder is removed in the return type. The closure is invoked once for each unique BoundRegionKind; multiple references to the same BoundRegionKind will reuse the previous result. A map is returned at the end with each bound region and the free region that replaced it.

Panics

This method only replaces late bound regions. Any types or constants bound by value will cause an ICE.

pub fn instantiate_bound_regions_uncached<T, F>( self, value: Binder<DbInterner<'db>, T>, replace_regions: F, ) -> T

where F: FnMut(BoundRegion) -> Region<'db>, T: TypeFoldable<DbInterner<'db>>,

pub fn instantiate_bound_regions_with_erased<T>( self, value: Binder<DbInterner<'db>, T>, ) -> T

where T: TypeFoldable<DbInterner<'db>>,

Replaces any late-bound regions bound in value with 'erased. Useful in codegen but also method lookup and a few other places where precise region relationships are not required.

impl<'db> DbInterner<'db>

pub fn conjure() -> DbInterner<'db>

pub fn new_no_crate(db: &'db (dyn HirDatabase + 'static)) -> DbInterner<'db>

Creates a new interner without an active crate. Good only for interning things, not for trait solving etc.. As a rule of thumb, when you create an InferCtxt, you need to provide the crate (and the block).

Elaboration is a special kind: it needs lang items (for Sized), therefore it needs new_with().

pub fn new_with( db: &'db (dyn HirDatabase + 'static), krate: Crate, ) -> DbInterner<'db>

pub fn db(&self) -> &'db (dyn HirDatabase + 'static)

pub fn lang_items(&self) -> &'db LangItems

impl<'db> DbInterner<'db>

pub fn shift_bound_var_indices<T>(self, bound_vars: usize, value: T) -> T

where T: TypeFoldable<DbInterner<'db>>,

pub fn replace_escaping_bound_vars_uncached<T>( self, value: T, delegate: impl BoundVarReplacerDelegate<'db>, ) -> T

where T: TypeFoldable<DbInterner<'db>>,

pub fn replace_bound_vars_uncached<T>( self, value: Binder<DbInterner<'db>, T>, delegate: impl BoundVarReplacerDelegate<'db>, ) -> T

where T: TypeFoldable<DbInterner<'db>>,

pub fn mk_fn_sig<I>( self, inputs: I, output: Ty<'db>, c_variadic: bool, safety: Safety, abi: FnAbi, ) -> FnSig<DbInterner<'db>>

where I: IntoIterator<Item = Ty<'db>>,

Trait Implementations

impl<'db> Abi<DbInterner<'db>> for FnAbi

fn rust() -> FnAbi

fn is_rust(self) -> bool

Whether this ABI is extern "Rust".

impl<'db> AdtDef<DbInterner<'db>> for AdtDef

fn def_id(self) -> AdtIdWrapper

fn is_struct(self) -> bool

fn is_phantom_data(self) -> bool

fn is_fundamental(self) -> bool

fn struct_tail_ty( self, interner: DbInterner<'db>, ) -> Option<EarlyBinder<DbInterner<'db>, Ty<'db>>>

Returns the type of the struct tail.

fn all_field_tys( self, interner: DbInterner<'db>, ) -> EarlyBinder<DbInterner<'db>, impl IntoIterator<Item = Ty<'db>>>

fn sizedness_constraint( self, interner: DbInterner<'db>, sizedness: SizedTraitKind, ) -> Option<EarlyBinder<DbInterner<'db>, Ty<'db>>>

fn destructor(self, _interner: DbInterner<'db>) -> Option<AdtDestructorKind>

fn is_manually_drop(self) -> bool

impl<'db> BoundExistentialPredicates<DbInterner<'db>> for BoundExistentialPredicates<'db>

fn principal_def_id(self) -> Option<TraitIdWrapper>

fn principal( self, ) -> Option<Binder<DbInterner<'db>, ExistentialTraitRef<DbInterner<'db>>>>

fn auto_traits(self) -> impl IntoIterator<Item = TraitIdWrapper>

fn projection_bounds( self, ) -> impl IntoIterator<Item = Binder<DbInterner<'db>, ExistentialProjection<DbInterner<'db>>>>

impl<'db> BoundVarLike<DbInterner<'db>> for BoundConst

fn var(self) -> BoundVar

fn assert_eq(self, var: BoundVarKind)

impl<'db> BoundVarLike<DbInterner<'db>> for BoundRegion

fn var(self) -> BoundVar

fn assert_eq(self, var: BoundVarKind)

impl<'db> BoundVarLike<DbInterner<'db>> for BoundTy

fn var(self) -> BoundVar

fn assert_eq(self, var: BoundVarKind)

impl<'db> Clause<DbInterner<'db>> for Clause<'db>

fn as_predicate(self) -> <DbInterner<'db> as Interner>::Predicate

fn instantiate_supertrait( self, cx: DbInterner<'db>, trait_ref: Binder<DbInterner<'db>, TraitRef<DbInterner<'db>>>, ) -> Clause<'db>

Performs a instantiation suitable for going from a poly-trait-ref to supertraits that must hold if that poly-trait-ref holds. This is slightly different from a normal instantiation in terms of what happens with bound regions.

fn as_trait_clause(self) -> Option<Binder<I, TraitPredicate<I>>>

fn as_host_effect_clause(self) -> Option<Binder<I, HostEffectPredicate<I>>>

fn as_projection_clause(self) -> Option<Binder<I, ProjectionPredicate<I>>>

impl<'db> Clone for DbInterner<'db>

fn clone(&self) -> DbInterner<'db>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'db> Const<DbInterner<'db>> for Const<'db>

fn new_infer(interner: DbInterner<'db>, var: InferConst) -> Const<'db>

fn new_var(interner: DbInterner<'db>, var: ConstVid) -> Const<'db>

fn new_bound( interner: DbInterner<'db>, debruijn: DebruijnIndex, var: BoundConst, ) -> Const<'db>

fn new_anon_bound( interner: DbInterner<'db>, debruijn: DebruijnIndex, var: BoundVar, ) -> Const<'db>

fn new_canonical_bound(interner: DbInterner<'db>, var: BoundVar) -> Const<'db>

fn new_placeholder( interner: DbInterner<'db>, param: <DbInterner<'db> as Interner>::PlaceholderConst, ) -> Const<'db>

fn new_unevaluated( interner: DbInterner<'db>, uv: UnevaluatedConst<DbInterner<'db>>, ) -> Const<'db>

fn new_expr(interner: DbInterner<'db>, expr: ExprConst) -> Const<'db>

fn new_error(interner: DbInterner<'db>, guar: ErrorGuaranteed) -> Const<'db>

fn new_error_with_message(interner: I, msg: impl ToString) -> Self

fn is_ct_var(self) -> bool

fn is_ct_error(self) -> bool

impl<'db> DbInternerInferExt<'db> for DbInterner<'db>

fn infer_ctxt(self) -> InferCtxtBuilder<'db>

impl<'db> Debug for DbInterner<'db>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'db> DefId<DbInterner<'db>> for AdtIdWrapper

fn as_local(self) -> Option<SolverDefId>

fn is_local(self) -> bool

impl<'db> DefId<DbInterner<'db>> for CallableIdWrapper

fn as_local(self) -> Option<SolverDefId>

fn is_local(self) -> bool

impl<'db> DefId<DbInterner<'db>> for ClosureIdWrapper

fn as_local(self) -> Option<SolverDefId>

fn is_local(self) -> bool

impl<'db> DefId<DbInterner<'db>> for CoroutineIdWrapper

fn as_local(self) -> Option<SolverDefId>

fn is_local(self) -> bool

impl<'db> DefId<DbInterner<'db>> for GeneralConstIdWrapper

fn as_local(self) -> Option<SolverDefId>

fn is_local(self) -> bool

impl<'db> DefId<DbInterner<'db>> for ImplIdWrapper

fn as_local(self) -> Option<SolverDefId>

fn is_local(self) -> bool

impl<'db> DefId<DbInterner<'db>> for SolverDefId

fn as_local(self) -> Option<SolverDefId>

fn is_local(self) -> bool

impl<'db> DefId<DbInterner<'db>> for TraitIdWrapper

fn as_local(self) -> Option<SolverDefId>

fn is_local(self) -> bool

impl<'db> DefId<DbInterner<'db>> for TypeAliasIdWrapper

fn as_local(self) -> Option<SolverDefId>

fn is_local(self) -> bool

impl<'db> Elaboratable<DbInterner<'db>> for Clause<'db>

fn predicate(&self) -> <DbInterner<'db> as Interner>::Predicate

fn child(&self, clause: <DbInterner<'db> as Interner>::Clause) -> Clause<'db>

fn child_with_derived_cause( &self, clause: <DbInterner<'db> as Interner>::Clause, _span: <DbInterner<'db> as Interner>::Span, _parent_trait_pred: Binder<DbInterner<'db>, TraitPredicate<DbInterner<'db>>>, _index: usize, ) -> Clause<'db>

impl<'db> Elaboratable<DbInterner<'db>> for Predicate<'db>

fn predicate(&self) -> <DbInterner<'db> as Interner>::Predicate

fn child(&self, clause: <DbInterner<'db> as Interner>::Clause) -> Predicate<'db>

fn child_with_derived_cause( &self, clause: <DbInterner<'db> as Interner>::Clause, _span: <DbInterner<'db> as Interner>::Span, _parent_trait_pred: Binder<DbInterner<'db>, TraitPredicate<DbInterner<'db>>>, _index: usize, ) -> Predicate<'db>

impl<'db> ExprConst<DbInterner<'db>> for ExprConst

fn args(self) -> <DbInterner<'db> as Interner>::GenericArgs

impl<'db> Features<DbInterner<'db>> for Features

fn generic_const_exprs(self) -> bool

fn coroutine_clone(self) -> bool

fn associated_const_equality(self) -> bool

fn feature_bound_holds_in_crate(self, _symbol: ()) -> bool

impl<'db> GenericArg<DbInterner<'db>> for GenericArg<'db>

fn as_term(&self) -> Option<<I as Interner>::Term>

fn as_type(&self) -> Option<<I as Interner>::Ty>

fn expect_ty(&self) -> <I as Interner>::Ty

fn as_const(&self) -> Option<<I as Interner>::Const>

fn expect_const(&self) -> <I as Interner>::Const

fn as_region(&self) -> Option<<I as Interner>::Region>

fn expect_region(&self) -> <I as Interner>::Region

fn is_non_region_infer(self) -> bool

impl<'db> GenericArgs<DbInterner<'db>> for GenericArgs<'db>

fn as_closure(self) -> ClosureArgs<DbInterner<'db>>

fn as_coroutine(self) -> CoroutineArgs<DbInterner<'db>>

fn as_coroutine_closure(self) -> CoroutineClosureArgs<DbInterner<'db>>

fn rebase_onto( self, interner: DbInterner<'db>, source_def_id: <DbInterner<'db> as Interner>::DefId, target: <DbInterner<'db> as Interner>::GenericArgs, ) -> <DbInterner<'db> as Interner>::GenericArgs

fn identity_for_item( interner: DbInterner<'db>, def_id: <DbInterner<'db> as Interner>::DefId, ) -> <DbInterner<'db> as Interner>::GenericArgs

fn extend_with_error( interner: DbInterner<'db>, def_id: <DbInterner<'db> as Interner>::DefId, original_args: &[<DbInterner<'db> as Interner>::GenericArg], ) -> <DbInterner<'db> as Interner>::GenericArgs

fn type_at(self, i: usize) -> <DbInterner<'db> as Interner>::Ty

fn region_at(self, i: usize) -> <DbInterner<'db> as Interner>::Region

fn const_at(self, i: usize) -> <DbInterner<'db> as Interner>::Const

fn split_closure_args(self) -> ClosureArgsParts<DbInterner<'db>>

fn split_coroutine_closure_args( self, ) -> CoroutineClosureArgsParts<DbInterner<'db>>

fn split_coroutine_args(self) -> CoroutineArgsParts<DbInterner<'db>>

impl<'db> GenericsOf<DbInterner<'db>> for Generics

fn count(&self) -> usize

impl<'db> HasDataLayout for DbInterner<'db>

fn data_layout(&self) -> &TargetDataLayout

impl<'db> Interner for DbInterner<'db>

type DefId = SolverDefId

type LocalDefId = SolverDefId

type LocalDefIds = SolverDefIds<'db>

type TraitId = TraitIdWrapper

type ForeignId = TypeAliasIdWrapper

type FunctionId = CallableIdWrapper

type ClosureId = ClosureIdWrapper

type CoroutineClosureId = CoroutineIdWrapper

type CoroutineId = CoroutineIdWrapper

type AdtId = AdtIdWrapper

type ImplId = ImplIdWrapper

type UnevaluatedConstId = GeneralConstIdWrapper

type Span = Span

type GenericArgs = GenericArgs<'db>

type GenericArgsSlice = GenericArgs<'db>

type GenericArg = GenericArg<'db>

type Term = Term<'db>

type BoundVarKinds = BoundVarKinds<'db>

type BoundVarKind = BoundVarKind

type PredefinedOpaques = PredefinedOpaques<'db>

type CanonicalVarKinds = CanonicalVars<'db>

type ExternalConstraints = ExternalConstraints<'db>

type DepNodeIndex = DepNodeIndex

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

type Ty = Ty<'db>

type Tys = Tys<'db>

type FnInputTys = Tys<'db>

type ParamTy = ParamTy

type BoundTy = BoundTy

type PlaceholderTy = Placeholder<BoundTy>

type Symbol = ()

type ErrorGuaranteed = ErrorGuaranteed

type BoundExistentialPredicates = BoundExistentialPredicates<'db>

type AllocId = AllocId

type Pat = Pattern<'db>

type PatList = PatList<'db>

type Safety = Safety

type Abi = FnAbi

type Const = Const<'db>

type PlaceholderConst = Placeholder<BoundConst>

type ParamConst = ParamConst

type BoundConst = BoundConst

type ValueConst = ValueConst<'db>

type ValTree = Valtree<'db>

type ExprConst = ExprConst

type Region = Region<'db>

type EarlyParamRegion = EarlyParamRegion

type LateParamRegion = LateParamRegion

type BoundRegion = BoundRegion

type PlaceholderRegion = Placeholder<BoundRegion>

type RegionAssumptions = RegionAssumptions<'db>

type ParamEnv = ParamEnv<'db>

type Predicate = Predicate<'db>

type Clause = Clause<'db>

type Clauses = Clauses<'db>

type GenericsOf = Generics

type VariancesOf = VariancesOf<'db>

type AdtDef = AdtDef

type Features = Features

type UnsizingParams = UnsizingParams

type Probe = Probe<DbInterner<'db>>

fn mk_predefined_opaques_in_body( self, data: &[(OpaqueTypeKey<DbInterner<'db>>, <DbInterner<'db> as Interner>::Ty)], ) -> <DbInterner<'db> as Interner>::PredefinedOpaques

fn mk_canonical_var_kinds( self, kinds: &[CanonicalVarKind<DbInterner<'db>>], ) -> <DbInterner<'db> as Interner>::CanonicalVarKinds

fn mk_external_constraints( self, data: ExternalConstraintsData<DbInterner<'db>>, ) -> <DbInterner<'db> as Interner>::ExternalConstraints

fn mk_args( self, args: &[<DbInterner<'db> as Interner>::GenericArg], ) -> <DbInterner<'db> as Interner>::GenericArgs

fn mk_args_from_iter<I, T>( self, args: I, ) -> <T as CollectAndApply<<DbInterner<'db> as Interner>::GenericArg, <DbInterner<'db> as Interner>::GenericArgs>>::Output

where I: Iterator<Item = T>, T: CollectAndApply<<DbInterner<'db> as Interner>::GenericArg, <DbInterner<'db> as Interner>::GenericArgs>,

fn mk_tracked<T>( self, data: T, _dep_node: <DbInterner<'db> as Interner>::DepNodeIndex, ) -> <DbInterner<'db> as Interner>::Tracked<T>

where T: Debug + Clone,

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

where T: Debug + Clone,

fn with_cached_task<T>( self, task: impl FnOnce() -> T, ) -> (T, <DbInterner<'db> as Interner>::DepNodeIndex)

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

fn canonical_param_env_cache_get_or_insert<R>( self, _param_env: <DbInterner<'db> as Interner>::ParamEnv, f: impl FnOnce() -> CanonicalParamEnvCacheEntry<DbInterner<'db>>, from_entry: impl FnOnce(&CanonicalParamEnvCacheEntry<DbInterner<'db>>) -> 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

where T: TypeFoldable<DbInterner<'db>>,

fn generics_of( self, def_id: <DbInterner<'db> as Interner>::DefId, ) -> <DbInterner<'db> as Interner>::GenericsOf

fn variances_of( self, def_id: <DbInterner<'db> as Interner>::DefId, ) -> <DbInterner<'db> as Interner>::VariancesOf

fn type_of( self, def_id: <DbInterner<'db> as Interner>::DefId, ) -> EarlyBinder<DbInterner<'db>, <DbInterner<'db> as Interner>::Ty>

fn adt_def( self, def_id: <DbInterner<'db> as Interner>::AdtId, ) -> <DbInterner<'db> as Interner>::AdtDef

fn alias_ty_kind(self, alias: AliasTy<DbInterner<'db>>) -> AliasTyKind

fn alias_term_kind(self, alias: AliasTerm<DbInterner<'db>>) -> AliasTermKind

fn trait_ref_and_own_args_for_alias( self, def_id: <DbInterner<'db> as Interner>::DefId, args: <DbInterner<'db> as Interner>::GenericArgs, ) -> (TraitRef<DbInterner<'db>>, <DbInterner<'db> as Interner>::GenericArgsSlice)

fn check_args_compatible( self, _def_id: <DbInterner<'db> as Interner>::DefId, _args: <DbInterner<'db> as Interner>::GenericArgs, ) -> bool

fn debug_assert_args_compatible( self, _def_id: <DbInterner<'db> as Interner>::DefId, _args: <DbInterner<'db> as Interner>::GenericArgs, )

fn debug_assert_existential_args_compatible( self, _def_id: <DbInterner<'db> as Interner>::DefId, _args: <DbInterner<'db> as Interner>::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<<DbInterner<'db> as Interner>::Ty, <DbInterner<'db> as Interner>::Tys>>::Output

where I: Iterator<Item = T>, T: CollectAndApply<<DbInterner<'db> as Interner>::Ty, <DbInterner<'db> as Interner>::Tys>,

fn parent( self, def_id: <DbInterner<'db> as Interner>::DefId, ) -> <DbInterner<'db> as Interner>::DefId

fn recursion_limit(self) -> usize

fn features(self) -> <DbInterner<'db> as Interner>::Features

fn fn_sig( self, def_id: <DbInterner<'db> as Interner>::FunctionId, ) -> EarlyBinder<DbInterner<'db>, Binder<DbInterner<'db>, FnSig<DbInterner<'db>>>>

fn coroutine_movability( self, def_id: <DbInterner<'db> as Interner>::CoroutineId, ) -> Movability

fn coroutine_for_closure( self, def_id: <DbInterner<'db> as Interner>::CoroutineClosureId, ) -> <DbInterner<'db> as Interner>::CoroutineId

fn generics_require_sized_self( self, def_id: <DbInterner<'db> as Interner>::DefId, ) -> bool

fn item_bounds( self, def_id: <DbInterner<'db> as Interner>::DefId, ) -> EarlyBinder<DbInterner<'db>, impl IntoIterator<Item = <DbInterner<'db> as Interner>::Clause>>

fn item_self_bounds( self, def_id: <DbInterner<'db> as Interner>::DefId, ) -> EarlyBinder<DbInterner<'db>, impl IntoIterator<Item = <DbInterner<'db> as Interner>::Clause>>

fn item_non_self_bounds( self, def_id: <DbInterner<'db> as Interner>::DefId, ) -> EarlyBinder<DbInterner<'db>, impl IntoIterator<Item = <DbInterner<'db> as Interner>::Clause>>

fn predicates_of( self, def_id: <DbInterner<'db> as Interner>::DefId, ) -> EarlyBinder<DbInterner<'db>, impl IntoIterator<Item = <DbInterner<'db> as Interner>::Clause>>

fn own_predicates_of( self, def_id: <DbInterner<'db> as Interner>::DefId, ) -> EarlyBinder<DbInterner<'db>, impl IntoIterator<Item = <DbInterner<'db> as Interner>::Clause>>

fn explicit_super_predicates_of( self, def_id: <DbInterner<'db> as Interner>::TraitId, ) -> EarlyBinder<DbInterner<'db>, impl IntoIterator<Item = (<DbInterner<'db> as Interner>::Clause, <DbInterner<'db> as Interner>::Span)>>

fn explicit_implied_predicates_of( self, def_id: <DbInterner<'db> as Interner>::DefId, ) -> EarlyBinder<DbInterner<'db>, impl IntoIterator<Item = (<DbInterner<'db> as Interner>::Clause, <DbInterner<'db> as Interner>::Span)>>

fn impl_super_outlives( self, impl_id: <DbInterner<'db> as Interner>::ImplId, ) -> EarlyBinder<DbInterner<'db>, impl IntoIterator<Item = <DbInterner<'db> as Interner>::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 const_conditions( self, _def_id: <DbInterner<'db> as Interner>::DefId, ) -> EarlyBinder<DbInterner<'db>, impl IntoIterator<Item = Binder<DbInterner<'db>, TraitRef<DbInterner<'db>>>>>

fn has_target_features( self, _def_id: <DbInterner<'db> as Interner>::FunctionId, ) -> bool

fn require_lang_item( self, lang_item: SolverLangItem, ) -> <DbInterner<'db> as Interner>::DefId

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

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

fn is_lang_item( self, def_id: <DbInterner<'db> as Interner>::DefId, lang_item: SolverLangItem, ) -> bool

fn is_trait_lang_item( self, def_id: <DbInterner<'db> as Interner>::TraitId, lang_item: SolverTraitLangItem, ) -> bool

fn is_adt_lang_item( self, def_id: <DbInterner<'db> as Interner>::AdtId, lang_item: SolverAdtLangItem, ) -> bool

fn as_lang_item( self, def_id: <DbInterner<'db> as Interner>::DefId, ) -> Option<SolverLangItem>

fn as_trait_lang_item( self, def_id: <DbInterner<'db> as Interner>::TraitId, ) -> Option<SolverTraitLangItem>

fn as_adt_lang_item( self, def_id: <DbInterner<'db> as Interner>::AdtId, ) -> Option<SolverAdtLangItem>

fn associated_type_def_ids( self, def_id: <DbInterner<'db> as Interner>::TraitId, ) -> impl IntoIterator<Item = <DbInterner<'db> as Interner>::DefId>

fn for_each_relevant_impl( self, trait_def_id: <DbInterner<'db> as Interner>::TraitId, self_ty: <DbInterner<'db> as Interner>::Ty, f: impl FnMut(<DbInterner<'db> as Interner>::ImplId), )

fn for_each_blanket_impl( self, trait_def_id: <DbInterner<'db> as Interner>::TraitId, f: impl FnMut(<DbInterner<'db> as Interner>::ImplId), )

fn has_item_definition( self, _def_id: <DbInterner<'db> as Interner>::DefId, ) -> bool

fn impl_is_default( self, impl_def_id: <DbInterner<'db> as Interner>::ImplId, ) -> bool

fn impl_trait_ref( self, impl_id: <DbInterner<'db> as Interner>::ImplId, ) -> EarlyBinder<DbInterner<'db>, TraitRef<DbInterner<'db>>>

fn impl_polarity( self, impl_id: <DbInterner<'db> as Interner>::ImplId, ) -> ImplPolarity

fn trait_is_auto(self, trait_: <DbInterner<'db> as Interner>::TraitId) -> bool

fn trait_is_alias(self, trait_: <DbInterner<'db> as Interner>::TraitId) -> bool

fn trait_is_dyn_compatible( self, trait_: <DbInterner<'db> as Interner>::TraitId, ) -> bool

fn trait_is_fundamental( self, trait_: <DbInterner<'db> as Interner>::TraitId, ) -> bool

fn trait_may_be_implemented_via_object( self, _trait_def_id: <DbInterner<'db> as Interner>::TraitId, ) -> bool

fn is_impl_trait_in_trait( self, _def_id: <DbInterner<'db> as Interner>::DefId, ) -> bool

fn delay_bug( self, msg: impl ToString, ) -> <DbInterner<'db> as Interner>::ErrorGuaranteed

fn is_general_coroutine( self, def_id: <DbInterner<'db> as Interner>::CoroutineId, ) -> bool

fn coroutine_is_async( self, def_id: <DbInterner<'db> as Interner>::CoroutineId, ) -> bool

fn coroutine_is_gen( self, _coroutine_def_id: <DbInterner<'db> as Interner>::CoroutineId, ) -> bool

fn coroutine_is_async_gen( self, _coroutine_def_id: <DbInterner<'db> as Interner>::CoroutineId, ) -> bool

fn unsizing_params_for_adt( self, id: <DbInterner<'db> as Interner>::AdtId, ) -> <DbInterner<'db> as Interner>::UnsizingParams

fn anonymize_bound_vars<T>( self, value: Binder<DbInterner<'db>, T>, ) -> Binder<DbInterner<'db>, T>

where T: TypeFoldable<DbInterner<'db>>,

fn opaque_types_defined_by( self, def_id: <DbInterner<'db> as Interner>::LocalDefId, ) -> <DbInterner<'db> as Interner>::LocalDefIds

fn opaque_types_and_coroutines_defined_by( self, def_id: <DbInterner<'db> as Interner>::LocalDefId, ) -> <DbInterner<'db> as Interner>::LocalDefIds

fn alias_has_const_conditions( self, _def_id: <DbInterner<'db> as Interner>::DefId, ) -> bool

fn explicit_implied_const_bounds( self, _def_id: <DbInterner<'db> as Interner>::DefId, ) -> EarlyBinder<DbInterner<'db>, impl IntoIterator<Item = Binder<DbInterner<'db>, TraitRef<DbInterner<'db>>>>>

fn fn_is_const(self, id: <DbInterner<'db> as Interner>::FunctionId) -> bool

fn impl_is_const(self, _def_id: <DbInterner<'db> as Interner>::ImplId) -> bool

fn opt_alias_variances( self, _kind: impl Into<AliasTermKind>, _def_id: <DbInterner<'db> as Interner>::DefId, ) -> Option<<DbInterner<'db> as Interner>::VariancesOf>

fn type_of_opaque_hir_typeck( self, def_id: <DbInterner<'db> as Interner>::LocalDefId, ) -> EarlyBinder<DbInterner<'db>, <DbInterner<'db> as Interner>::Ty>

fn coroutine_hidden_types( self, _def_id: <DbInterner<'db> as Interner>::CoroutineId, ) -> EarlyBinder<DbInterner<'db>, Binder<DbInterner<'db>, CoroutineWitnessTypes<DbInterner<'db>>>>

fn is_default_trait( self, def_id: <DbInterner<'db> as Interner>::TraitId, ) -> bool

fn trait_is_coinductive( self, trait_: <DbInterner<'db> as Interner>::TraitId, ) -> bool

fn trait_is_unsafe(self, trait_: <DbInterner<'db> as Interner>::TraitId) -> bool

Returns true if this is an unsafe trait.

fn impl_self_is_guaranteed_unsized( self, _def_id: <DbInterner<'db> as Interner>::ImplId, ) -> bool

fn impl_specializes( self, specializing_impl_def_id: <DbInterner<'db> as Interner>::ImplId, parent_impl_def_id: <DbInterner<'db> as Interner>::ImplId, ) -> bool

fn next_trait_solver_globally(self) -> bool

fn mk_probe( self, probe: Probe<DbInterner<'db>>, ) -> <DbInterner<'db> as Interner>::Probe

fn evaluate_root_goal_for_proof_tree_raw( self, canonical_goal: CanonicalQueryInput<DbInterner<'db>, QueryInput<DbInterner<'db>, <DbInterner<'db> as Interner>::Predicate>>, ) -> (Result<Canonical<DbInterner<'db>, Response<DbInterner<'db>>>, NoSolution>, <DbInterner<'db> as Interner>::Probe)

fn is_sizedness_trait( self, def_id: <DbInterner<'db> as Interner>::TraitId, ) -> bool

impl<'db> IrPrint<AliasTerm<DbInterner<'db>>> for DbInterner<'db>

fn print( t: &AliasTerm<DbInterner<'db>>, fmt: &mut Formatter<'_>, ) -> Result<(), Error>

fn print_debug( t: &AliasTerm<DbInterner<'db>>, fmt: &mut Formatter<'_>, ) -> Result<(), Error>

impl<'db> IrPrint<AliasTy<DbInterner<'db>>> for DbInterner<'db>

fn print( t: &AliasTy<DbInterner<'db>>, fmt: &mut Formatter<'_>, ) -> Result<(), Error>

fn print_debug( t: &AliasTy<DbInterner<'db>>, fmt: &mut Formatter<'_>, ) -> Result<(), Error>

impl<'db> IrPrint<CoercePredicate<DbInterner<'db>>> for DbInterner<'db>

fn print( t: &CoercePredicate<DbInterner<'db>>, fmt: &mut Formatter<'_>, ) -> Result<(), Error>

fn print_debug( t: &CoercePredicate<DbInterner<'db>>, fmt: &mut Formatter<'_>, ) -> Result<(), Error>

impl<'db> IrPrint<ExistentialProjection<DbInterner<'db>>> for DbInterner<'db>

fn print( t: &ExistentialProjection<DbInterner<'db>>, fmt: &mut Formatter<'_>, ) -> Result<(), Error>

fn print_debug( t: &ExistentialProjection<DbInterner<'db>>, fmt: &mut Formatter<'_>, ) -> Result<(), Error>

impl<'db> IrPrint<ExistentialTraitRef<DbInterner<'db>>> for DbInterner<'db>

fn print( t: &ExistentialTraitRef<DbInterner<'db>>, fmt: &mut Formatter<'_>, ) -> Result<(), Error>

fn print_debug( t: &ExistentialTraitRef<DbInterner<'db>>, fmt: &mut Formatter<'_>, ) -> Result<(), Error>

impl<'db> IrPrint<FnSig<DbInterner<'db>>> for DbInterner<'db>

fn print( t: &FnSig<DbInterner<'db>>, fmt: &mut Formatter<'_>, ) -> Result<(), Error>

fn print_debug( t: &FnSig<DbInterner<'db>>, fmt: &mut Formatter<'_>, ) -> Result<(), Error>

impl<'db> IrPrint<HostEffectPredicate<DbInterner<'db>>> for DbInterner<'db>

fn print( t: &HostEffectPredicate<DbInterner<'db>>, fmt: &mut Formatter<'_>, ) -> Result<(), Error>

fn print_debug( t: &HostEffectPredicate<DbInterner<'db>>, fmt: &mut Formatter<'_>, ) -> Result<(), Error>

impl<'db> IrPrint<NormalizesTo<DbInterner<'db>>> for DbInterner<'db>

fn print( t: &NormalizesTo<DbInterner<'db>>, fmt: &mut Formatter<'_>, ) -> Result<(), Error>

fn print_debug( t: &NormalizesTo<DbInterner<'db>>, fmt: &mut Formatter<'_>, ) -> Result<(), Error>

impl<'db> IrPrint<PatternKind<DbInterner<'db>>> for DbInterner<'db>

fn print( t: &PatternKind<DbInterner<'db>>, fmt: &mut Formatter<'_>, ) -> Result<(), Error>

fn print_debug( t: &PatternKind<DbInterner<'db>>, fmt: &mut Formatter<'_>, ) -> Result<(), Error>

impl<'db> IrPrint<ProjectionPredicate<DbInterner<'db>>> for DbInterner<'db>

fn print( t: &ProjectionPredicate<DbInterner<'db>>, fmt: &mut Formatter<'_>, ) -> Result<(), Error>

fn print_debug( t: &ProjectionPredicate<DbInterner<'db>>, fmt: &mut Formatter<'_>, ) -> Result<(), Error>

impl<'db> IrPrint<SubtypePredicate<DbInterner<'db>>> for DbInterner<'db>

fn print( t: &SubtypePredicate<DbInterner<'db>>, fmt: &mut Formatter<'_>, ) -> Result<(), Error>

fn print_debug( t: &SubtypePredicate<DbInterner<'db>>, fmt: &mut Formatter<'_>, ) -> Result<(), Error>

impl<'db> IrPrint<TraitPredicate<DbInterner<'db>>> for DbInterner<'db>

fn print( t: &TraitPredicate<DbInterner<'db>>, fmt: &mut Formatter<'_>, ) -> Result<(), Error>

fn print_debug( t: &TraitPredicate<DbInterner<'db>>, fmt: &mut Formatter<'_>, ) -> Result<(), Error>

impl<'db> IrPrint<TraitRef<DbInterner<'db>>> for DbInterner<'db>

fn print( t: &TraitRef<DbInterner<'db>>, fmt: &mut Formatter<'_>, ) -> Result<(), Error>

fn print_debug( t: &TraitRef<DbInterner<'db>>, fmt: &mut Formatter<'_>, ) -> Result<(), Error>

impl<'db> ParamEnv<DbInterner<'db>> for ParamEnv<'db>

fn caller_bounds(self) -> impl SliceLike<Item = Clause<'db>>

impl<'db> PlaceholderLike<DbInterner<'db>> for Placeholder<BoundConst>

type Bound = BoundConst

fn universe(self) -> UniverseIndex

fn var(self) -> BoundVar

fn with_updated_universe(self, ui: UniverseIndex) -> Placeholder<BoundConst>

fn new(ui: UniverseIndex, var: BoundConst) -> Placeholder<BoundConst>

fn new_anon(ui: UniverseIndex, var: BoundVar) -> Placeholder<BoundConst>

impl<'db> PlaceholderLike<DbInterner<'db>> for Placeholder<BoundRegion>

type Bound = BoundRegion

fn universe(self) -> UniverseIndex

fn var(self) -> BoundVar

fn with_updated_universe(self, ui: UniverseIndex) -> Placeholder<BoundRegion>

fn new( ui: UniverseIndex, bound: <Placeholder<BoundRegion> as PlaceholderLike<DbInterner<'db>>>::Bound, ) -> Placeholder<BoundRegion>

fn new_anon(ui: UniverseIndex, var: BoundVar) -> Placeholder<BoundRegion>

impl<'db> PlaceholderLike<DbInterner<'db>> for Placeholder<BoundTy>

type Bound = BoundTy

fn universe(self) -> UniverseIndex

fn var(self) -> BoundVar

fn with_updated_universe(self, ui: UniverseIndex) -> Placeholder<BoundTy>

fn new(ui: UniverseIndex, bound: BoundTy) -> Placeholder<BoundTy>

fn new_anon(ui: UniverseIndex, var: BoundVar) -> Placeholder<BoundTy>

impl<'db> Predicate<DbInterner<'db>> for Predicate<'db>

fn allow_normalization(self) -> bool

Whether this projection can be soundly normalized.

Wf predicates must not be normalized, as normalization can remove required bounds which would cause us to unsoundly accept some programs. See #91068.

fn as_clause(self) -> Option<<DbInterner<'db> as Interner>::Clause>

fn as_normalizes_to(self) -> Option<Binder<I, NormalizesTo<I>>>

impl<'db> Region<DbInterner<'db>> for Region<'db>

fn new_bound( interner: DbInterner<'db>, debruijn: DebruijnIndex, var: BoundRegion, ) -> Region<'db>

fn new_anon_bound( interner: DbInterner<'db>, debruijn: DebruijnIndex, var: BoundVar, ) -> Region<'db>

fn new_canonical_bound(interner: DbInterner<'db>, var: BoundVar) -> Region<'db>

fn new_static(interner: DbInterner<'db>) -> Region<'db>

fn new_placeholder( interner: DbInterner<'db>, var: <DbInterner<'db> as Interner>::PlaceholderRegion, ) -> Region<'db>

fn is_bound(self) -> bool

impl<'db> Relate<DbInterner<'db>> for BoundExistentialPredicates<'db>

fn relate<R>( relation: &mut R, a: BoundExistentialPredicates<'db>, b: BoundExistentialPredicates<'db>, ) -> Result<BoundExistentialPredicates<'db>, TypeError<DbInterner<'db>>>

where R: TypeRelation<DbInterner<'db>>,

impl<'db> Relate<DbInterner<'db>> for Const<'db>

fn relate<R>( relation: &mut R, a: Const<'db>, b: Const<'db>, ) -> Result<Const<'db>, TypeError<DbInterner<'db>>>

where R: TypeRelation<DbInterner<'db>>,

impl<'db> Relate<DbInterner<'db>> for ExprConst

fn relate<R>( _relation: &mut R, a: ExprConst, b: ExprConst, ) -> Result<ExprConst, TypeError<DbInterner<'db>>>

where R: TypeRelation<DbInterner<'db>>,

impl<'db> Relate<DbInterner<'db>> for FnAbi

fn relate<R>( _relation: &mut R, a: FnAbi, b: FnAbi, ) -> Result<FnAbi, TypeError<DbInterner<'db>>>

where R: TypeRelation<DbInterner<'db>>,

impl<'db> Relate<DbInterner<'db>> for GenericArg<'db>

fn relate<R>( relation: &mut R, a: GenericArg<'db>, b: GenericArg<'db>, ) -> Result<GenericArg<'db>, TypeError<DbInterner<'db>>>

where R: TypeRelation<DbInterner<'db>>,

impl<'db> Relate<DbInterner<'db>> for GenericArgs<'db>

fn relate<R>( relation: &mut R, a: GenericArgs<'db>, b: GenericArgs<'db>, ) -> Result<GenericArgs<'db>, TypeError<DbInterner<'db>>>

where R: TypeRelation<DbInterner<'db>>,

impl<'db> Relate<DbInterner<'db>> for Pattern<'db>

fn relate<R>( relation: &mut R, a: Pattern<'db>, b: Pattern<'db>, ) -> Result<Pattern<'db>, TypeError<DbInterner<'db>>>

where R: TypeRelation<DbInterner<'db>>,

impl<'db> Relate<DbInterner<'db>> for Region<'db>

fn relate<R>( relation: &mut R, a: Region<'db>, b: Region<'db>, ) -> Result<Region<'db>, TypeError<DbInterner<'db>>>

where R: TypeRelation<DbInterner<'db>>,

impl<'db> Relate<DbInterner<'db>> for Safety

fn relate<R>( _relation: &mut R, a: Safety, b: Safety, ) -> Result<Safety, TypeError<DbInterner<'db>>>

where R: TypeRelation<DbInterner<'db>>,

impl<'db> Relate<DbInterner<'db>> for Term<'db>

fn relate<R>( relation: &mut R, a: Term<'db>, b: Term<'db>, ) -> Result<Term<'db>, TypeError<DbInterner<'db>>>

where R: TypeRelation<DbInterner<'db>>,

impl<'db> Relate<DbInterner<'db>> for Ty<'db>

fn relate<R>( relation: &mut R, a: Ty<'db>, b: Ty<'db>, ) -> Result<Ty<'db>, TypeError<DbInterner<'db>>>

where R: TypeRelation<DbInterner<'db>>,

impl<'db> Safety<DbInterner<'db>> for Safety

fn safe() -> Safety

fn is_safe(self) -> bool

fn prefix_str(self) -> &'static str

impl<'db> Span<DbInterner<'db>> for Span

fn dummy() -> Span

impl<'db> Term<DbInterner<'db>> for Term<'db>

fn as_type(&self) -> Option<<I as Interner>::Ty>

fn expect_ty(&self) -> <I as Interner>::Ty

fn as_const(&self) -> Option<<I as Interner>::Const>

fn expect_const(&self) -> <I as Interner>::Const

fn is_infer(self) -> bool

fn is_error(self) -> bool

fn to_alias_term(self) -> Option<AliasTerm<I>>

impl<'db> Ty<DbInterner<'db>> for Ty<'db>

fn new_unit(interner: DbInterner<'db>) -> Ty<'db>

fn new_bool(interner: DbInterner<'db>) -> Ty<'db>

fn new_u8(interner: DbInterner<'db>) -> Ty<'db>

fn new_usize(interner: DbInterner<'db>) -> Ty<'db>

fn new_infer(interner: DbInterner<'db>, var: InferTy) -> Ty<'db>

fn new_var(interner: DbInterner<'db>, var: TyVid) -> Ty<'db>

fn new_param(interner: DbInterner<'db>, param: ParamTy) -> Ty<'db>

fn new_placeholder( interner: DbInterner<'db>, param: Placeholder<BoundTy>, ) -> Ty<'db>

fn new_bound( interner: DbInterner<'db>, debruijn: DebruijnIndex, var: BoundTy, ) -> Ty<'db>

fn new_anon_bound( interner: DbInterner<'db>, debruijn: DebruijnIndex, var: BoundVar, ) -> Ty<'db>

fn new_canonical_bound(interner: DbInterner<'db>, var: BoundVar) -> Ty<'db>

fn new_alias( interner: DbInterner<'db>, kind: AliasTyKind, alias_ty: AliasTy<DbInterner<'db>>, ) -> Ty<'db>

fn new_error(interner: DbInterner<'db>, guar: ErrorGuaranteed) -> Ty<'db>

fn new_adt( interner: DbInterner<'db>, adt_def: <DbInterner<'db> as Interner>::AdtDef, args: GenericArgs<'db>, ) -> Ty<'db>

fn new_foreign(interner: DbInterner<'db>, def_id: TypeAliasIdWrapper) -> Ty<'db>

fn new_dynamic( interner: DbInterner<'db>, preds: <DbInterner<'db> as Interner>::BoundExistentialPredicates, region: <DbInterner<'db> as Interner>::Region, ) -> Ty<'db>

fn new_coroutine( interner: DbInterner<'db>, def_id: CoroutineIdWrapper, args: <DbInterner<'db> as Interner>::GenericArgs, ) -> Ty<'db>

fn new_coroutine_closure( interner: DbInterner<'db>, def_id: CoroutineIdWrapper, args: <DbInterner<'db> as Interner>::GenericArgs, ) -> Ty<'db>

fn new_closure( interner: DbInterner<'db>, def_id: ClosureIdWrapper, args: <DbInterner<'db> as Interner>::GenericArgs, ) -> Ty<'db>

fn new_coroutine_witness( interner: DbInterner<'db>, def_id: CoroutineIdWrapper, args: <DbInterner<'db> as Interner>::GenericArgs, ) -> Ty<'db>

fn new_coroutine_witness_for_coroutine( interner: DbInterner<'db>, def_id: CoroutineIdWrapper, coroutine_args: <DbInterner<'db> as Interner>::GenericArgs, ) -> Ty<'db>

fn new_ptr(interner: DbInterner<'db>, ty: Ty<'db>, mutbl: Mutability) -> Ty<'db>

fn new_ref( interner: DbInterner<'db>, region: <DbInterner<'db> as Interner>::Region, ty: Ty<'db>, mutbl: Mutability, ) -> Ty<'db>

fn new_array_with_const_len( interner: DbInterner<'db>, ty: Ty<'db>, len: <DbInterner<'db> as Interner>::Const, ) -> Ty<'db>

fn new_slice(interner: DbInterner<'db>, ty: Ty<'db>) -> Ty<'db>

fn new_tup( interner: DbInterner<'db>, tys: &[<DbInterner<'db> as Interner>::Ty], ) -> Ty<'db>

fn new_tup_from_iter<It, T>( interner: DbInterner<'db>, iter: It, ) -> <T as CollectAndApply<Ty<'db>, Ty<'db>>>::Output

where It: Iterator<Item = T>, T: CollectAndApply<Ty<'db>, Ty<'db>>,

fn new_fn_def( interner: DbInterner<'db>, def_id: CallableIdWrapper, args: <DbInterner<'db> as Interner>::GenericArgs, ) -> Ty<'db>

fn new_fn_ptr( interner: DbInterner<'db>, sig: Binder<DbInterner<'db>, FnSig<DbInterner<'db>>>, ) -> Ty<'db>

fn new_pat( interner: DbInterner<'db>, ty: Ty<'db>, pat: <DbInterner<'db> as Interner>::Pat, ) -> Ty<'db>

fn new_unsafe_binder( interner: DbInterner<'db>, ty: Binder<DbInterner<'db>, <DbInterner<'db> as Interner>::Ty>, ) -> Ty<'db>

fn tuple_fields(self) -> <DbInterner<'db> as Interner>::Tys

fn to_opt_closure_kind(self) -> Option<ClosureKind>

fn from_closure_kind(interner: DbInterner<'db>, kind: ClosureKind) -> Ty<'db>

fn from_coroutine_closure_kind( interner: DbInterner<'db>, kind: ClosureKind, ) -> Ty<'db>

fn has_unsafe_fields(self) -> bool

Checks whether this type is an ADT that has unsafe fields.

fn discriminant_ty( self, interner: DbInterner<'db>, ) -> <DbInterner<'db> as Interner>::Ty

fn new_projection_from_args( interner: I, def_id: <I as Interner>::DefId, args: <I as Interner>::GenericArgs, ) -> Self

fn new_projection( interner: I, def_id: <I as Interner>::DefId, args: impl IntoIterator>, ) -> Self

where <impl IntoIterator as IntoIterator>::Item: Into<<I as Interner>::GenericArg>,

fn is_ty_var(self) -> bool

fn is_ty_error(self) -> bool

fn is_floating_point(self) -> bool

fn is_integral(self) -> bool

fn is_fn_ptr(self) -> bool

fn fn_sig(self, interner: I) -> Binder<I, FnSig<I>>

fn is_known_rigid(self) -> bool

fn is_guaranteed_unsized_raw(self) -> bool

impl<'db> TypeFoldable<DbInterner<'db>> for AdtIdWrapper

fn try_fold_with<F>( self, _: &mut F, ) -> Result<AdtIdWrapper, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, _: &mut F) -> AdtIdWrapper

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for BoundExistentialPredicates<'db>

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<BoundExistentialPredicates<'db>, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, folder: &mut F) -> BoundExistentialPredicates<'db>

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for BoundRegion

fn try_fold_with<F>( self, _: &mut F, ) -> Result<BoundRegion, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, _: &mut F) -> BoundRegion

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for CallableIdWrapper

fn try_fold_with<F>( self, _: &mut F, ) -> Result<CallableIdWrapper, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, _: &mut F) -> CallableIdWrapper

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for Clause<'db>

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<Clause<'db>, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, folder: &mut F) -> Clause<'db>

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for Clauses<'db>

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<Clauses<'db>, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, folder: &mut F) -> Clauses<'db>

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for ClosureIdWrapper

fn try_fold_with<F>( self, _: &mut F, ) -> Result<ClosureIdWrapper, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, _: &mut F) -> ClosureIdWrapper

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for Const<'db>

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<Const<'db>, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, folder: &mut F) -> Const<'db>

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for CoroutineIdWrapper

fn try_fold_with<F>( self, _: &mut F, ) -> Result<CoroutineIdWrapper, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, _: &mut F) -> CoroutineIdWrapper

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for ErrorGuaranteed

fn try_fold_with<F>( self, _folder: &mut F, ) -> Result<ErrorGuaranteed, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, _folder: &mut F) -> ErrorGuaranteed

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for ExprConst

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<ExprConst, <__F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where __F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<__F>(self, __folder: &mut __F) -> ExprConst

where __F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for ExternalConstraints<'db>

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<ExternalConstraints<'db>, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, folder: &mut F) -> ExternalConstraints<'db>

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for FnAbi

fn try_fold_with<F>( self, _: &mut F, ) -> Result<FnAbi, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, _: &mut F) -> FnAbi

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for GeneralConstIdWrapper

fn try_fold_with<F>( self, _: &mut F, ) -> Result<GeneralConstIdWrapper, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, _: &mut F) -> GeneralConstIdWrapper

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for GenericArg<'db>

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<GenericArg<'db>, <__F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where __F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<__F>(self, __folder: &mut __F) -> GenericArg<'db>

where __F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for GenericArgs<'db>

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<GenericArgs<'db>, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, folder: &mut F) -> GenericArgs<'db>

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for ImplIdWrapper

fn try_fold_with<F>( self, _: &mut F, ) -> Result<ImplIdWrapper, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, _: &mut F) -> ImplIdWrapper

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for OpaqueHiddenType<'db>

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<OpaqueHiddenType<'db>, <__F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where __F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<__F>(self, __folder: &mut __F) -> OpaqueHiddenType<'db>

where __F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for ParamConst

fn try_fold_with<F>( self, _: &mut F, ) -> Result<ParamConst, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, _: &mut F) -> ParamConst

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for ParamEnv<'db>

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<ParamEnv<'db>, <__F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where __F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<__F>(self, __folder: &mut __F) -> ParamEnv<'db>

where __F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for ParamTy

fn try_fold_with<F>( self, _: &mut F, ) -> Result<ParamTy, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, _: &mut F) -> ParamTy

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for PatList<'db>

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<PatList<'db>, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, folder: &mut F) -> PatList<'db>

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for Pattern<'db>

fn try_fold_with<F>( self, _: &mut F, ) -> Result<Pattern<'db>, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, _: &mut F) -> Pattern<'db>

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for Placeholder<BoundRegion>

fn try_fold_with<F>( self, _: &mut F, ) -> Result<Placeholder<BoundRegion>, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, _: &mut F) -> Placeholder<BoundRegion>

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for Placeholder<BoundTy>

fn try_fold_with<F>( self, _: &mut F, ) -> Result<Placeholder<BoundTy>, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, _: &mut F) -> Placeholder<BoundTy>

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for Placeholder<BoundVar>

fn try_fold_with<F>( self, _: &mut F, ) -> Result<Placeholder<BoundVar>, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, _: &mut F) -> Placeholder<BoundVar>

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for PredefinedOpaques<'db>

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<PredefinedOpaques<'db>, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, folder: &mut F) -> PredefinedOpaques<'db>

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for Predicate<'db>

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<Predicate<'db>, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, folder: &mut F) -> Predicate<'db>

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for QueryRegionConstraints<'db>

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<QueryRegionConstraints<'db>, <__F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where __F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<__F>(self, __folder: &mut __F) -> QueryRegionConstraints<'db>

where __F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db, R> TypeFoldable<DbInterner<'db>> for QueryResponse<'db, R>

where R: TypeFoldable<DbInterner<'db>>,

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<QueryResponse<'db, R>, <__F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where __F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<__F>(self, __folder: &mut __F) -> QueryResponse<'db, R>

where __F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for Region<'db>

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<Region<'db>, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, folder: &mut F) -> Region<'db>

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for RegionAssumptions<'db>

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<RegionAssumptions<'db>, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, folder: &mut F) -> RegionAssumptions<'db>

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for Safety

fn try_fold_with<F>( self, _: &mut F, ) -> Result<Safety, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, _: &mut F) -> Safety

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for SolverDefId

fn try_fold_with<F>( self, _: &mut F, ) -> Result<SolverDefId, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, _: &mut F) -> SolverDefId

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for SolverDefIds<'db>

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<SolverDefIds<'db>, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, folder: &mut F) -> SolverDefIds<'db>

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for Span

fn try_fold_with<F>( self, _: &mut F, ) -> Result<Span, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, _: &mut F) -> Span

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for Term<'db>

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<Term<'db>, <__F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where __F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<__F>(self, __folder: &mut __F) -> Term<'db>

where __F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for TraitIdWrapper

fn try_fold_with<F>( self, _: &mut F, ) -> Result<TraitIdWrapper, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, _: &mut F) -> TraitIdWrapper

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for Ty<'db>

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<Ty<'db>, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, folder: &mut F) -> Ty<'db>

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for TypeAliasIdWrapper

fn try_fold_with<F>( self, _: &mut F, ) -> Result<TypeAliasIdWrapper, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, _: &mut F) -> TypeAliasIdWrapper

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for Tys<'db>

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<Tys<'db>, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, folder: &mut F) -> Tys<'db>

where F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db> TypeFoldable<DbInterner<'db>> for ValueConst<'db>

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<ValueConst<'db>, <__F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where __F: FallibleTypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<__F>(self, __folder: &mut __F) -> ValueConst<'db>

where __F: TypeFolder<DbInterner<'db>>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'db, F, G, H> TypeFolder<DbInterner<'db>> for BottomUpFolder<'db, F, G, H>

where F: FnMut(Ty<'db>) -> Ty<'db>, G: FnMut(Region<'db>) -> Region<'db>, H: FnMut(Const<'db>) -> Const<'db>,

fn cx(&self) -> DbInterner<'db>

fn fold_ty(&mut self, ty: Ty<'db>) -> Ty<'db>

fn fold_region(&mut self, r: Region<'db>) -> Region<'db>

fn fold_const(&mut self, ct: Const<'db>) -> Const<'db>

fn fold_binder<T>(&mut self, t: Binder<I, T>) -> Binder<I, T>

where T: TypeFoldable<I>,

fn fold_predicate( &mut self, p: <I as Interner>::Predicate, ) -> <I as Interner>::Predicate

fn fold_clauses( &mut self, c: <I as Interner>::Clauses, ) -> <I as Interner>::Clauses

impl<'a, 'db> TypeFolder<DbInterner<'db>> for OpportunisticVarResolver<'a, 'db>

fn cx(&self) -> DbInterner<'db>

fn fold_ty(&mut self, t: Ty<'db>) -> Ty<'db>

fn fold_const(&mut self, ct: Const<'db>) -> Const<'db>

fn fold_binder<T>(&mut self, t: Binder<I, T>) -> Binder<I, T>

where T: TypeFoldable<I>,

fn fold_region(&mut self, r: <I as Interner>::Region) -> <I as Interner>::Region

fn fold_predicate( &mut self, p: <I as Interner>::Predicate, ) -> <I as Interner>::Predicate

fn fold_clauses( &mut self, c: <I as Interner>::Clauses, ) -> <I as Interner>::Clauses

impl<'db> TypeFolder<DbInterner<'db>> for PlaceholderReplacer<'_, 'db>

fn cx(&self) -> DbInterner<'db>

fn fold_binder<T>( &mut self, t: Binder<DbInterner<'db>, T>, ) -> Binder<DbInterner<'db>, T>

where T: TypeFoldable<DbInterner<'db>>,

fn fold_region(&mut self, r0: Region<'db>) -> Region<'db>

fn fold_ty(&mut self, ty: Ty<'db>) -> Ty<'db>

fn fold_const(&mut self, ct: Const<'db>) -> Const<'db>

fn fold_predicate( &mut self, p: <I as Interner>::Predicate, ) -> <I as Interner>::Predicate

fn fold_clauses( &mut self, c: <I as Interner>::Clauses, ) -> <I as Interner>::Clauses

impl<'db> TypeFolder<DbInterner<'db>> for ReplaceInferWithError<'db>

fn cx(&self) -> DbInterner<'db>

fn fold_ty(&mut self, t: Ty<'db>) -> Ty<'db>

fn fold_const(&mut self, c: Const<'db>) -> Const<'db>

fn fold_region(&mut self, r: Region<'db>) -> Region<'db>

fn fold_binder<T>(&mut self, t: Binder<I, T>) -> Binder<I, T>

where T: TypeFoldable<I>,

fn fold_predicate( &mut self, p: <I as Interner>::Predicate, ) -> <I as Interner>::Predicate

fn fold_clauses( &mut self, c: <I as Interner>::Clauses, ) -> <I as Interner>::Clauses

impl<'db> TypeSuperFoldable<DbInterner<'db>> for Clauses<'db>

fn try_super_fold_with<F>( self, folder: &mut F, ) -> Result<Clauses<'db>, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

Provides a default fold for a recursive type of interest. This should only be called within TypeFolder methods, when a non-custom traversal is desired for the value of the type of interest passed to that method. For example, in MyFolder::try_fold_ty(ty), it is valid to call ty.try_super_fold_with(self), but any other folding should be done with xyz.try_fold_with(self).

fn super_fold_with<F>(self, folder: &mut F) -> Clauses<'db>

where F: TypeFolder<DbInterner<'db>>,

A convenient alternative to try_super_fold_with for use with infallible folders. Do not override this method, to ensure coherence with try_super_fold_with.

impl<'db> TypeSuperFoldable<DbInterner<'db>> for Const<'db>

fn try_super_fold_with<F>( self, folder: &mut F, ) -> Result<Const<'db>, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

Provides a default fold for a recursive type of interest. This should only be called within TypeFolder methods, when a non-custom traversal is desired for the value of the type of interest passed to that method. For example, in MyFolder::try_fold_ty(ty), it is valid to call ty.try_super_fold_with(self), but any other folding should be done with xyz.try_fold_with(self).

fn super_fold_with<F>(self, folder: &mut F) -> Const<'db>

where F: TypeFolder<DbInterner<'db>>,

A convenient alternative to try_super_fold_with for use with infallible folders. Do not override this method, to ensure coherence with try_super_fold_with.

impl<'db> TypeSuperFoldable<DbInterner<'db>> for Predicate<'db>

fn try_super_fold_with<F>( self, folder: &mut F, ) -> Result<Predicate<'db>, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

Provides a default fold for a recursive type of interest. This should only be called within TypeFolder methods, when a non-custom traversal is desired for the value of the type of interest passed to that method. For example, in MyFolder::try_fold_ty(ty), it is valid to call ty.try_super_fold_with(self), but any other folding should be done with xyz.try_fold_with(self).

fn super_fold_with<F>(self, folder: &mut F) -> Predicate<'db>

where F: TypeFolder<DbInterner<'db>>,

A convenient alternative to try_super_fold_with for use with infallible folders. Do not override this method, to ensure coherence with try_super_fold_with.

impl<'db> TypeSuperFoldable<DbInterner<'db>> for Ty<'db>

fn try_super_fold_with<F>( self, folder: &mut F, ) -> Result<Ty<'db>, <F as FallibleTypeFolder<DbInterner<'db>>>::Error>

where F: FallibleTypeFolder<DbInterner<'db>>,

Provides a default fold for a recursive type of interest. This should only be called within TypeFolder methods, when a non-custom traversal is desired for the value of the type of interest passed to that method. For example, in MyFolder::try_fold_ty(ty), it is valid to call ty.try_super_fold_with(self), but any other folding should be done with xyz.try_fold_with(self).

fn super_fold_with<F>(self, folder: &mut F) -> Ty<'db>

where F: TypeFolder<DbInterner<'db>>,

A convenient alternative to try_super_fold_with for use with infallible folders. Do not override this method, to ensure coherence with try_super_fold_with.

impl<'db> TypeSuperVisitable<DbInterner<'db>> for Clauses<'db>

fn super_visit_with<V>( &self, visitor: &mut V, ) -> <V as TypeVisitor<DbInterner<'db>>>::Result

where V: TypeVisitor<DbInterner<'db>>,

Provides a default visit for a recursive type of interest. This should only be called within TypeVisitor methods, when a non-custom traversal is desired for the value of the type of interest passed to that method. For example, in MyVisitor::visit_ty(ty), it is valid to call ty.super_visit_with(self), but any other visiting should be done with xyz.visit_with(self).

impl<'db> TypeSuperVisitable<DbInterner<'db>> for Const<'db>

fn super_visit_with<V>( &self, visitor: &mut V, ) -> <V as TypeVisitor<DbInterner<'db>>>::Result

where V: TypeVisitor<DbInterner<'db>>,

Provides a default visit for a recursive type of interest. This should only be called within TypeVisitor methods, when a non-custom traversal is desired for the value of the type of interest passed to that method. For example, in MyVisitor::visit_ty(ty), it is valid to call ty.super_visit_with(self), but any other visiting should be done with xyz.visit_with(self).

impl<'db> TypeSuperVisitable<DbInterner<'db>> for Predicate<'db>

fn super_visit_with<V>( &self, visitor: &mut V, ) -> <V as TypeVisitor<DbInterner<'db>>>::Result

where V: TypeVisitor<DbInterner<'db>>,

Provides a default visit for a recursive type of interest. This should only be called within TypeVisitor methods, when a non-custom traversal is desired for the value of the type of interest passed to that method. For example, in MyVisitor::visit_ty(ty), it is valid to call ty.super_visit_with(self), but any other visiting should be done with xyz.visit_with(self).

impl<'db> TypeSuperVisitable<DbInterner<'db>> for Ty<'db>

fn super_visit_with<V>( &self, visitor: &mut V, ) -> <V as TypeVisitor<DbInterner<'db>>>::Result

where V: TypeVisitor<DbInterner<'db>>,

Provides a default visit for a recursive type of interest. This should only be called within TypeVisitor methods, when a non-custom traversal is desired for the value of the type of interest passed to that method. For example, in MyVisitor::visit_ty(ty), it is valid to call ty.super_visit_with(self), but any other visiting should be done with xyz.visit_with(self).

impl<'db> TypeVisitable<DbInterner<'db>> for AdtIdWrapper

fn visit_with<F>( &self, _: &mut F, ) -> <F as TypeVisitor<DbInterner<'db>>>::Result

where F: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for BoundExistentialPredicates<'db>

fn visit_with<V>( &self, visitor: &mut V, ) -> <V as TypeVisitor<DbInterner<'db>>>::Result

where V: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for BoundRegion

fn visit_with<F>( &self, _: &mut F, ) -> <F as TypeVisitor<DbInterner<'db>>>::Result

where F: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for CallableIdWrapper

fn visit_with<F>( &self, _: &mut F, ) -> <F as TypeVisitor<DbInterner<'db>>>::Result

where F: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for Clause<'db>

fn visit_with<V>( &self, visitor: &mut V, ) -> <V as TypeVisitor<DbInterner<'db>>>::Result

where V: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for Clauses<'db>

fn visit_with<V>( &self, visitor: &mut V, ) -> <V as TypeVisitor<DbInterner<'db>>>::Result

where V: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for ClosureIdWrapper

fn visit_with<F>( &self, _: &mut F, ) -> <F as TypeVisitor<DbInterner<'db>>>::Result

where F: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for Const<'db>

fn visit_with<V>( &self, visitor: &mut V, ) -> <V as TypeVisitor<DbInterner<'db>>>::Result

where V: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for CoroutineIdWrapper

fn visit_with<F>( &self, _: &mut F, ) -> <F as TypeVisitor<DbInterner<'db>>>::Result

where F: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for ErrorGuaranteed

fn visit_with<V>( &self, visitor: &mut V, ) -> <V as TypeVisitor<DbInterner<'db>>>::Result

where V: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for ExprConst

fn visit_with<__V>( &self, __visitor: &mut __V, ) -> <__V as TypeVisitor<DbInterner<'db>>>::Result

where __V: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for ExternalConstraints<'db>

fn visit_with<V>( &self, visitor: &mut V, ) -> <V as TypeVisitor<DbInterner<'db>>>::Result

where V: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for FnAbi

fn visit_with<F>( &self, _: &mut F, ) -> <F as TypeVisitor<DbInterner<'db>>>::Result

where F: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for GeneralConstIdWrapper

fn visit_with<F>( &self, _: &mut F, ) -> <F as TypeVisitor<DbInterner<'db>>>::Result

where F: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for GenericArg<'db>

fn visit_with<__V>( &self, __visitor: &mut __V, ) -> <__V as TypeVisitor<DbInterner<'db>>>::Result

where __V: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for GenericArgs<'db>

fn visit_with<V>( &self, visitor: &mut V, ) -> <V as TypeVisitor<DbInterner<'db>>>::Result

where V: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for ImplIdWrapper

fn visit_with<F>( &self, _: &mut F, ) -> <F as TypeVisitor<DbInterner<'db>>>::Result

where F: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for OpaqueHiddenType<'db>

fn visit_with<__V>( &self, __visitor: &mut __V, ) -> <__V as TypeVisitor<DbInterner<'db>>>::Result

where __V: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for ParamConst

fn visit_with<F>( &self, _: &mut F, ) -> <F as TypeVisitor<DbInterner<'db>>>::Result

where F: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for ParamEnv<'db>

fn visit_with<__V>( &self, __visitor: &mut __V, ) -> <__V as TypeVisitor<DbInterner<'db>>>::Result

where __V: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for ParamTy

fn visit_with<F>( &self, _: &mut F, ) -> <F as TypeVisitor<DbInterner<'db>>>::Result

where F: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for PatList<'db>

fn visit_with<V>( &self, visitor: &mut V, ) -> <V as TypeVisitor<DbInterner<'db>>>::Result

where V: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for Pattern<'db>

fn visit_with<F>( &self, _: &mut F, ) -> <F as TypeVisitor<DbInterner<'db>>>::Result

where F: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for Placeholder<BoundRegion>

fn visit_with<F>( &self, _: &mut F, ) -> <F as TypeVisitor<DbInterner<'db>>>::Result

where F: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for Placeholder<BoundTy>

fn visit_with<F>( &self, _: &mut F, ) -> <F as TypeVisitor<DbInterner<'db>>>::Result

where F: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for Placeholder<BoundVar>

fn visit_with<F>( &self, _: &mut F, ) -> <F as TypeVisitor<DbInterner<'db>>>::Result

where F: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for PredefinedOpaques<'db>

fn visit_with<V>( &self, visitor: &mut V, ) -> <V as TypeVisitor<DbInterner<'db>>>::Result

where V: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for Predicate<'db>

fn visit_with<V>( &self, visitor: &mut V, ) -> <V as TypeVisitor<DbInterner<'db>>>::Result

where V: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for QueryRegionConstraints<'db>

fn visit_with<__V>( &self, __visitor: &mut __V, ) -> <__V as TypeVisitor<DbInterner<'db>>>::Result

where __V: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db, R> TypeVisitable<DbInterner<'db>> for QueryResponse<'db, R>

where R: TypeVisitable<DbInterner<'db>>,

fn visit_with<__V>( &self, __visitor: &mut __V, ) -> <__V as TypeVisitor<DbInterner<'db>>>::Result

where __V: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for Region<'db>

fn visit_with<V>( &self, visitor: &mut V, ) -> <V as TypeVisitor<DbInterner<'db>>>::Result

where V: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for RegionAssumptions<'db>

fn visit_with<V>( &self, visitor: &mut V, ) -> <V as TypeVisitor<DbInterner<'db>>>::Result

where V: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for Safety

fn visit_with<F>( &self, _: &mut F, ) -> <F as TypeVisitor<DbInterner<'db>>>::Result

where F: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for SolverDefId

fn visit_with<F>( &self, _: &mut F, ) -> <F as TypeVisitor<DbInterner<'db>>>::Result

where F: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for SolverDefIds<'db>

fn visit_with<V>( &self, visitor: &mut V, ) -> <V as TypeVisitor<DbInterner<'db>>>::Result

where V: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for Span

fn visit_with<F>( &self, _: &mut F, ) -> <F as TypeVisitor<DbInterner<'db>>>::Result

where F: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for Term<'db>

fn visit_with<__V>( &self, __visitor: &mut __V, ) -> <__V as TypeVisitor<DbInterner<'db>>>::Result

where __V: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for TraitIdWrapper

fn visit_with<F>( &self, _: &mut F, ) -> <F as TypeVisitor<DbInterner<'db>>>::Result

where F: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for Ty<'db>

fn visit_with<V>( &self, visitor: &mut V, ) -> <V as TypeVisitor<DbInterner<'db>>>::Result

where V: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for TypeAliasIdWrapper

fn visit_with<F>( &self, _: &mut F, ) -> <F as TypeVisitor<DbInterner<'db>>>::Result

where F: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for Tys<'db>

fn visit_with<V>( &self, visitor: &mut V, ) -> <V as TypeVisitor<DbInterner<'db>>>::Result

where V: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitable<DbInterner<'db>> for ValueConst<'db>

fn visit_with<__V>( &self, __visitor: &mut __V, ) -> <__V as TypeVisitor<DbInterner<'db>>>::Result

where __V: TypeVisitor<DbInterner<'db>>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'db> TypeVisitor<DbInterner<'db>> for ContainsTypeErrors

type Result = ControlFlow<()>

fn visit_ty( &mut self, t: Ty<'db>, ) -> <ContainsTypeErrors as TypeVisitor<DbInterner<'db>>>::Result

fn visit_binder<T>(&mut self, t: &Binder<I, T>) -> Self::Result

where T: TypeVisitable<I>,

fn visit_region(&mut self, r: <I as Interner>::Region) -> Self::Result

fn visit_const(&mut self, c: <I as Interner>::Const) -> Self::Result

fn visit_predicate(&mut self, p: <I as Interner>::Predicate) -> Self::Result

fn visit_clauses(&mut self, c: <I as Interner>::Clauses) -> Self::Result

fn visit_error( &mut self, _guar: <I as Interner>::ErrorGuaranteed, ) -> Self::Result

impl<'db> TypeVisitor<DbInterner<'db>> for MaxUniverse

type Result = ()

fn visit_ty(&mut self, t: Ty<'db>)

fn visit_const(&mut self, c: Const<'db>)

fn visit_region(&mut self, r: Region<'db>)

fn visit_binder<T>(&mut self, t: &Binder<I, T>) -> Self::Result

where T: TypeVisitable<I>,

fn visit_predicate(&mut self, p: <I as Interner>::Predicate) -> Self::Result

fn visit_clauses(&mut self, c: <I as Interner>::Clauses) -> Self::Result

fn visit_error( &mut self, _guar: <I as Interner>::ErrorGuaranteed, ) -> Self::Result

impl<'db> TypeVisitor<DbInterner<'db>> for StalledOnCoroutines<'_, 'db>

type Result = ControlFlow<()>

fn visit_ty( &mut self, ty: Ty<'db>, ) -> <StalledOnCoroutines<'_, 'db> as TypeVisitor<DbInterner<'db>>>::Result

fn visit_binder<T>(&mut self, t: &Binder<I, T>) -> Self::Result

where T: TypeVisitable<I>,

fn visit_region(&mut self, r: <I as Interner>::Region) -> Self::Result

fn visit_const(&mut self, c: <I as Interner>::Const) -> Self::Result

fn visit_predicate(&mut self, p: <I as Interner>::Predicate) -> Self::Result

fn visit_clauses(&mut self, c: <I as Interner>::Clauses) -> Self::Result

fn visit_error( &mut self, _guar: <I as Interner>::ErrorGuaranteed, ) -> Self::Result

impl<'db> Tys<DbInterner<'db>> for Tys<'db>

fn inputs(self) -> <DbInterner<'db> as Interner>::FnInputTys

fn output(self) -> <DbInterner<'db> as Interner>::Ty

impl<'db> UpcastFrom<DbInterner<'db>, Binder<DbInterner<'db>, ClauseKind<DbInterner<'db>>>> for Clause<'db>

fn upcast_from( from: Binder<DbInterner<'db>, ClauseKind<DbInterner<'db>>>, interner: DbInterner<'db>, ) -> Clause<'db>

impl<'db> UpcastFrom<DbInterner<'db>, Binder<DbInterner<'db>, ClauseKind<DbInterner<'db>>>> for Predicate<'db>

fn upcast_from( from: Binder<DbInterner<'db>, ClauseKind<DbInterner<'db>>>, interner: DbInterner<'db>, ) -> Predicate<'db>

impl<'db> UpcastFrom<DbInterner<'db>, Binder<DbInterner<'db>, OutlivesPredicate<DbInterner<'db>, Region<'db>>>> for Predicate<'db>

fn upcast_from( from: Binder<DbInterner<'db>, OutlivesPredicate<DbInterner<'db>, Region<'db>>>, tcx: DbInterner<'db>, ) -> Predicate<'db>

impl<'db> UpcastFrom<DbInterner<'db>, Binder<DbInterner<'db>, PredicateKind<DbInterner<'db>>>> for Predicate<'db>

fn upcast_from( from: Binder<DbInterner<'db>, PredicateKind<DbInterner<'db>>>, interner: DbInterner<'db>, ) -> Predicate<'db>

impl<'db> UpcastFrom<DbInterner<'db>, Binder<DbInterner<'db>, ProjectionPredicate<DbInterner<'db>>>> for Clause<'db>

fn upcast_from( from: Binder<DbInterner<'db>, ProjectionPredicate<DbInterner<'db>>>, interner: DbInterner<'db>, ) -> Clause<'db>

impl<'db> UpcastFrom<DbInterner<'db>, Binder<DbInterner<'db>, ProjectionPredicate<DbInterner<'db>>>> for Predicate<'db>

fn upcast_from( from: Binder<DbInterner<'db>, ProjectionPredicate<DbInterner<'db>>>, interner: DbInterner<'db>, ) -> Predicate<'db>

impl<'db> UpcastFrom<DbInterner<'db>, Binder<DbInterner<'db>, TraitPredicate<DbInterner<'db>>>> for Clause<'db>

fn upcast_from( from: Binder<DbInterner<'db>, TraitPredicate<DbInterner<'db>>>, interner: DbInterner<'db>, ) -> Clause<'db>

impl<'db> UpcastFrom<DbInterner<'db>, Binder<DbInterner<'db>, TraitPredicate<DbInterner<'db>>>> for Predicate<'db>

fn upcast_from( from: Binder<DbInterner<'db>, TraitPredicate<DbInterner<'db>>>, interner: DbInterner<'db>, ) -> Predicate<'db>

impl<'db> UpcastFrom<DbInterner<'db>, Binder<DbInterner<'db>, TraitRef<DbInterner<'db>>>> for Clause<'db>

fn upcast_from( from: Binder<DbInterner<'db>, TraitRef<DbInterner<'db>>>, interner: DbInterner<'db>, ) -> Clause<'db>

impl<'db> UpcastFrom<DbInterner<'db>, Binder<DbInterner<'db>, TraitRef<DbInterner<'db>>>> for Predicate<'db>

fn upcast_from( from: Binder<DbInterner<'db>, TraitRef<DbInterner<'db>>>, interner: DbInterner<'db>, ) -> Predicate<'db>

impl<'db> UpcastFrom<DbInterner<'db>, Clause<'db>> for Predicate<'db>

fn upcast_from(from: Clause<'db>, _interner: DbInterner<'db>) -> Predicate<'db>

impl<'db> UpcastFrom<DbInterner<'db>, ClauseKind<DbInterner<'db>>> for Predicate<'db>

fn upcast_from( from: ClauseKind<DbInterner<'db>>, interner: DbInterner<'db>, ) -> Predicate<'db>

impl<'db> UpcastFrom<DbInterner<'db>, NormalizesTo<DbInterner<'db>>> for Predicate<'db>

fn upcast_from( from: NormalizesTo<DbInterner<'db>>, interner: DbInterner<'db>, ) -> Predicate<'db>

impl<'db> UpcastFrom<DbInterner<'db>, OutlivesPredicate<DbInterner<'db>, Region<'db>>> for Clause<'db>

fn upcast_from( from: OutlivesPredicate<DbInterner<'db>, Region<'db>>, interner: DbInterner<'db>, ) -> Clause<'db>

impl<'db> UpcastFrom<DbInterner<'db>, OutlivesPredicate<DbInterner<'db>, Region<'db>>> for Predicate<'db>

fn upcast_from( from: OutlivesPredicate<DbInterner<'db>, Region<'db>>, interner: DbInterner<'db>, ) -> Predicate<'db>

impl<'db> UpcastFrom<DbInterner<'db>, OutlivesPredicate<DbInterner<'db>, Ty<'db>>> for Clause<'db>

fn upcast_from( from: OutlivesPredicate<DbInterner<'db>, Ty<'db>>, interner: DbInterner<'db>, ) -> Clause<'db>

impl<'db> UpcastFrom<DbInterner<'db>, OutlivesPredicate<DbInterner<'db>, Ty<'db>>> for Predicate<'db>

fn upcast_from( from: OutlivesPredicate<DbInterner<'db>, Ty<'db>>, interner: DbInterner<'db>, ) -> Predicate<'db>

impl<'db> UpcastFrom<DbInterner<'db>, PredicateKind<DbInterner<'db>>> for Predicate<'db>

fn upcast_from( from: PredicateKind<DbInterner<'db>>, interner: DbInterner<'db>, ) -> Predicate<'db>

impl<'db> UpcastFrom<DbInterner<'db>, ProjectionPredicate<DbInterner<'db>>> for Clause<'db>

fn upcast_from( from: ProjectionPredicate<DbInterner<'db>>, interner: DbInterner<'db>, ) -> Clause<'db>

impl<'db> UpcastFrom<DbInterner<'db>, ProjectionPredicate<DbInterner<'db>>> for Predicate<'db>

fn upcast_from( from: ProjectionPredicate<DbInterner<'db>>, interner: DbInterner<'db>, ) -> Predicate<'db>

impl<'db> UpcastFrom<DbInterner<'db>, TraitPredicate<DbInterner<'db>>> for Clause<'db>

fn upcast_from( from: TraitPredicate<DbInterner<'db>>, interner: DbInterner<'db>, ) -> Clause<'db>

impl<'db> UpcastFrom<DbInterner<'db>, TraitPredicate<DbInterner<'db>>> for Predicate<'db>

fn upcast_from( from: TraitPredicate<DbInterner<'db>>, interner: DbInterner<'db>, ) -> Predicate<'db>

impl<'db> UpcastFrom<DbInterner<'db>, TraitRef<DbInterner<'db>>> for Clause<'db>

fn upcast_from( from: TraitRef<DbInterner<'db>>, interner: DbInterner<'db>, ) -> Clause<'db>

impl<'db> UpcastFrom<DbInterner<'db>, TraitRef<DbInterner<'db>>> for Predicate<'db>

fn upcast_from( from: TraitRef<DbInterner<'db>>, interner: DbInterner<'db>, ) -> Predicate<'db>

impl<'db> ValueConst<DbInterner<'db>> for ValueConst<'db>

fn ty(self) -> Ty<'db>

fn valtree(self) -> Valtree<'db>

impl<'db> Clauses<DbInterner<'db>> for Clauses<'db>

impl<'db> Copy for DbInterner<'db>

impl Send for DbInterner<'_>

impl Sync for DbInterner<'_>