Struct DbInterner 

pub struct DbInterner<'db> {
    pub db: &'db (dyn HirDatabase + 'static),
    krate: Option<Crate>,
    lang_items: Option<&'db LangItems>,
}

Fields

db: &'db (dyn HirDatabase + 'static)

krate: Option<Crate>

lang_items: Option<&'db LangItems>

Implementations

impl<'db> DbInterner<'db>

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

where F: FnMut(BoundRegion<DbInterner<'db>>) -> 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<DbInterner<'db>>) -> 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.

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

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

Replaces any late-bound regions bound in value with free variants attached to all_outlive_scope.

impl<'db> 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

pub fn default_types(&self) -> &'db DefaultAny<'db>

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: ExternAbi, ) -> FnSig<DbInterner<'db>>

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

pub fn mk_fn_sig_safe_rust_abi<I>( self, inputs: I, output: Ty<'db>, ) -> FnSig<DbInterner<'db>>

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

mk_fn_sig, but with a safe Rust ABI, and no C-variadic argument.

impl<'db> DbInterner<'db>

pub fn signature_unclosure( self, sig: Binder<DbInterner<'db>, FnSig<DbInterner<'db>>>, safety: Safety, ) -> Binder<DbInterner<'db>, FnSig<DbInterner<'db>>>

Given a closure signature, returns an equivalent fn signature. Detuples and so forth – so e.g., if we have a sig with Fn<(u32, i32)> then you would get a fn(u32, i32). unsafety determines the unsafety of the fn signature. If you pass Safety::Unsafe in the previous example, then you would get an unsafe fn (u32, i32). It cannot convert a closure that requires unsafe.

Trait Implementations

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_manually_drop(self) -> bool

fn is_packed(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 field_representing_type_info( self, _interner: DbInterner<'db>, _args: GenericArgs<'db>, ) -> Option<FieldInfo<DbInterner<'db>>>

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> 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> Clauses<DbInterner<'db>> for Clauses<'db>

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<DbInterner<'db>>, ) -> 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: Placeholder<DbInterner<'db>, BoundConst<DbInterner<'db>>>, ) -> 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> Copy for DbInterner<'db>

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>, OpaqueTyIdWrapper<'db>> for OpaqueTyIdWrapper<'db>

fn as_local(self) -> Option<OpaqueTyIdWrapper<'db>>

fn is_local(self) -> bool

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

fn as_local(self) -> Option<SolverDefId<'db>>

fn is_local(self) -> bool

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

fn as_local(self) -> Option<SolverDefId<'db>>

fn is_local(self) -> bool

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

fn as_local(self) -> Option<SolverDefId<'db>>

fn is_local(self) -> bool

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

fn as_local(self) -> Option<SolverDefId<'db>>

fn is_local(self) -> bool

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

fn as_local(self) -> Option<SolverDefId<'db>>

fn is_local(self) -> bool

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

fn as_local(self) -> Option<SolverDefId<'db>>

fn is_local(self) -> bool

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

fn as_local(self) -> Option<SolverDefId<'db>>

fn is_local(self) -> bool

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

fn as_local(self) -> Option<SolverDefId<'db>>

fn is_local(self) -> bool

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

fn as_local(self) -> Option<SolverDefId<'db>>

fn is_local(self) -> bool

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

fn as_local(self) -> Option<SolverDefId<'db>>

fn is_local(self) -> bool

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

fn as_local(self) -> Option<SolverDefId<'db>>

fn is_local(self) -> bool

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

fn as_local(self) -> Option<SolverDefId<'db>>

fn is_local(self) -> bool

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

fn as_local(self) -> Option<SolverDefId<'db>>

fn is_local(self) -> bool

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

fn as_local(self) -> Option<SolverDefId<'db>>

fn is_local(self) -> bool

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

fn as_local(self) -> Option<SolverDefId<'db>>

fn is_local(self) -> bool

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

fn as_local(self) -> Option<SolverDefId<'db>>

fn is_local(self) -> bool

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

fn as_local(self) -> Option<SolverDefId<'db>>

fn is_local(self) -> bool

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

fn as_local(self) -> Option<SolverDefId<'db>>

fn is_local(self) -> bool

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

fn as_local(self) -> Option<SolverDefId<'db>>

fn is_local(self) -> bool

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

fn as_local(self) -> Option<SolverDefId<'db>>

fn is_local(self) -> bool

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

fn as_local(self) -> Option<SolverDefId<'db>>

fn is_local(self) -> bool

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

fn as_local(self) -> Option<SolverDefId<'db>>

fn is_local(self) -> bool

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

For Obligation, a sub-obligation is combined with the current obligation’s param-env and cause code.

fn predicate(&self) -> Predicate<'db>

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

fn child_with_derived_cause( &self, clause: Clause<'db>, span: Span, _parent_trait_pred: Binder<DbInterner<'db>, TraitPredicate<DbInterner<'db>>>, _index: usize, ) -> Obligation<'db, Predicate<'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> 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> 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 generic_const_args(self) -> bool

fn feature_bound_holds_in_crate(self, _symbol: 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<'db>

fn count(&self) -> usize

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

fn data_layout(&self) -> &TargetDataLayout

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

type DefId = SolverDefId<'db>

type LocalDefId = SolverDefId<'db>

type LocalDefIds = SolverDefIds<'db>

type TraitId = TraitIdWrapper

type ForeignId = TypeAliasIdWrapper

type FunctionId = CallableIdWrapper

type ClosureId = ClosureIdWrapper<'db>

type CoroutineClosureId = CoroutineClosureIdWrapper<'db>

type CoroutineId = CoroutineIdWrapper<'db>

type AdtId = AdtIdWrapper

type ImplId = AnyImplId

type UnevaluatedConstId = GeneralConstIdWrapper<'db>

type TraitAssocTyId = TraitAssocTyId

type TraitAssocConstId = TraitAssocConstId

type TraitAssocTermId = TraitAssocTermId

type OpaqueTyId = OpaqueTyIdWrapper<'db>

type LocalOpaqueTyId = OpaqueTyIdWrapper<'db>

type FreeTyAliasId = FreeTyAliasId

type FreeConstAliasId = FreeConstAliasId

type FreeTermAliasId = FreeTermAliasId

type ImplOrTraitAssocTyId = ImplOrTraitAssocTyId

type ImplOrTraitAssocConstId = ImplOrTraitAssocConstId

type ImplOrTraitAssocTermId = ImplOrTraitAssocTermId

type InherentAssocTyId = InherentAssocTyId

type InherentAssocConstId = InherentAssocConstId

type InherentAssocTermId = InherentAssocTermId

type Span = Span

type GenericArgs = GenericArgs<'db>

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

type GenericArg = GenericArg<'db>

type Term = Term<'db>

type BoundVarKinds = BoundVarKinds<'db>

type PredefinedOpaques = PredefinedOpaques<'db>

type CanonicalVarKinds = CanonicalVarKinds<'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 = &'db [Ty<'db>]

type ParamTy = ParamTy

type Symbol = Symbol

type ErrorGuaranteed = ErrorGuaranteed

type BoundExistentialPredicates = BoundExistentialPredicates<'db>

type AllocId = AllocId

type Pat = Pattern<'db>

type PatList = PatList<'db>

type Safety = Safety

type Const = Const<'db>

type ParamConst = ParamConst

type ValueConst = ValueConst<'db>

type ValTree = ValTree<'db>

type Consts = Consts<'db>

type ScalarInt = ScalarInt

type ExprConst = ExprConst

type Region = Region<'db>

type EarlyParamRegion = EarlyParamRegion

type LateParamRegion = LateParamRegion<'db>

type RegionAssumptions = RegionAssumptions<'db>

type ParamEnv = ParamEnv<'db>

type Predicate = Predicate<'db>

type Clause = Clause<'db>

type Clauses = Clauses<'db>

type GenericsOf = Generics<'db>

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_term_kind_from_def_id( self, def_id: SolverDefId<'db>, ) -> AliasTermKind<DbInterner<'db>>

fn trait_ref_and_own_args_for_alias( self, def_id: <DbInterner<'db> as Interner>::TraitAssocTermId, 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 projection_parent( self, def_id: <DbInterner<'db> as Interner>::TraitAssocTermId, ) -> <DbInterner<'db> as Interner>::TraitId

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

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

fn inherent_alias_term_parent( self, def_id: <DbInterner<'db> as Interner>::InherentAssocTermId, ) -> <DbInterner<'db> as Interner>::ImplId

fn recursion_limit(self) -> usize

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

fn features(self) -> 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_projection_lang_item( self, lang_item: SolverProjectionLangItem, ) -> <DbInterner<'db> as Interner>::TraitAssocTyId

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

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

fn is_projection_lang_item( self, def_id: <DbInterner<'db> as Interner>::TraitAssocTyId, lang_item: SolverProjectionLangItem, ) -> 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_projection_lang_item( self, def_id: <DbInterner<'db> as Interner>::TraitAssocTyId, ) -> Option<SolverProjectionLangItem>

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<R>( self, trait_def_id: <DbInterner<'db> as Interner>::TraitId, self_ty: <DbInterner<'db> as Interner>::Ty, f: impl FnMut(<DbInterner<'db> as Interner>::ImplId) -> R, ) -> R

where R: VisitorResult,

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

where R: VisitorResult,

fn has_item_definition( self, _def_id: <DbInterner<'db> as Interner>::ImplOrTraitAssocTermId, ) -> 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 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, def_id: <DbInterner<'db> as Interner>::CoroutineId, ) -> bool

fn coroutine_is_async_gen( self, 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<DbInterner<'db>>>, ) -> Option<<DbInterner<'db> as Interner>::VariancesOf>

fn type_of_opaque_hir_typeck( self, opaque: <DbInterner<'db> as Interner>::LocalOpaqueTyId, ) -> 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

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

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

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

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

fn item_name( self, _item_index: <DbInterner<'db> as Interner>::DefId, ) -> <DbInterner<'db> as Interner>::Symbol

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> Predicate<DbInterner<'db>> for Predicate<'db>

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

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

fn allow_normalization(self) -> bool

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

fn new_bound( interner: DbInterner<'db>, debruijn: DebruijnIndex, var: BoundRegion<DbInterner<'db>>, ) -> 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: Placeholder<DbInterner<'db>, BoundRegion<DbInterner<'db>>>, ) -> Region<'db>

fn is_bound(self) -> bool

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 ExternAbi

fn relate<R>( _relation: &mut R, a: ExternAbi, b: ExternAbi, ) -> Result<ExternAbi, 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 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 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 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 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 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 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

The safe safety mode.

fn is_safe(self) -> bool

Is the safety mode Safe?

fn prefix_str(self) -> &'static str

The string prefix for this safety mode.

fn unsafe_mode() -> Safety

The unsafe safety mode.

impl Send for DbInterner<'_>

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

fn dummy() -> Span

impl<'db> Symbol<DbInterner<'db>> for Symbol

fn is_kw_underscore_lifetime(self) -> bool

impl Sync for DbInterner<'_>

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, interner: I) -> 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<DbInterner<'db>, BoundTy<DbInterner<'db>>>, ) -> Ty<'db>

fn new_bound( interner: DbInterner<'db>, debruijn: DebruijnIndex, var: BoundTy<DbInterner<'db>>, ) -> 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>, 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<'db>, args: <DbInterner<'db> as Interner>::GenericArgs, ) -> Ty<'db>

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

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

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

fn new_coroutine_witness_for_coroutine( interner: DbInterner<'db>, def_id: CoroutineIdWrapper<'db>, 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>) -> Ty<'db>

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

fn new_projection( interner: I, def_id: <I as Interner>::TraitAssocTyId, 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 Projection

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<Projection, <__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) -> Projection

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 Place

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<Place, <__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) -> Place

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 InferenceDiagnostic

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<InferenceDiagnostic, <__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) -> InferenceDiagnostic

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 StoredFnSig

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<StoredFnSig, <__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) -> StoredFnSig

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 StoredTraitRef

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<StoredTraitRef, <__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) -> StoredTraitRef

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> TypeFoldable<DbInterner<'db>> for ValTree<'db>

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<ValTree<'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) -> ValTree<'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 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 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 Consts<'db>

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<Consts<'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) -> Consts<'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 StoredGenericArg

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<StoredGenericArg, <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) -> StoredGenericArg

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

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<StoredGenericArgs, <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) -> StoredGenericArgs

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

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<ObligationCause, <__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) -> ObligationCause

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, T> TypeFoldable<DbInterner<'db>> for Obligation<'db, T>

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

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<Obligation<'db, T>, <__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) -> Obligation<'db, T>

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, folder: &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, folder: &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 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 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 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 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 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 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 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 CoroutineClosureIdWrapper<'_>

fn try_fold_with<F>( self, _: &mut F, ) -> Result<CoroutineClosureIdWrapper<'_>, <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) -> CoroutineClosureIdWrapper<'_>

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

fn try_fold_with<F>( self, _: &mut F, ) -> Result<TraitAssocTyId, <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) -> TraitAssocTyId

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 TraitAssocConstId

fn try_fold_with<F>( self, _: &mut F, ) -> Result<TraitAssocConstId, <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) -> TraitAssocConstId

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 TraitAssocTermId

fn try_fold_with<F>( self, _: &mut F, ) -> Result<TraitAssocTermId, <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) -> TraitAssocTermId

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 ImplOrTraitAssocTyId

fn try_fold_with<F>( self, _: &mut F, ) -> Result<ImplOrTraitAssocTyId, <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) -> ImplOrTraitAssocTyId

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 ImplOrTraitAssocConstId

fn try_fold_with<F>( self, _: &mut F, ) -> Result<ImplOrTraitAssocConstId, <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) -> ImplOrTraitAssocConstId

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 ImplOrTraitAssocTermId

fn try_fold_with<F>( self, _: &mut F, ) -> Result<ImplOrTraitAssocTermId, <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) -> ImplOrTraitAssocTermId

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 FreeTyAliasId

fn try_fold_with<F>( self, _: &mut F, ) -> Result<FreeTyAliasId, <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) -> FreeTyAliasId

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 FreeConstAliasId

fn try_fold_with<F>( self, _: &mut F, ) -> Result<FreeConstAliasId, <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) -> FreeConstAliasId

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 FreeTermAliasId

fn try_fold_with<F>( self, _: &mut F, ) -> Result<FreeTermAliasId, <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) -> FreeTermAliasId

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 InherentAssocTyId

fn try_fold_with<F>( self, _: &mut F, ) -> Result<InherentAssocTyId, <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) -> InherentAssocTyId

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 InherentAssocConstId

fn try_fold_with<F>( self, _: &mut F, ) -> Result<InherentAssocConstId, <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) -> InherentAssocConstId

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 InherentAssocTermId

fn try_fold_with<F>( self, _: &mut F, ) -> Result<InherentAssocTermId, <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) -> InherentAssocTermId

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 OpaqueTyIdWrapper<'_>

fn try_fold_with<F>( self, _: &mut F, ) -> Result<OpaqueTyIdWrapper<'_>, <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) -> OpaqueTyIdWrapper<'_>

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 AnyImplId

fn try_fold_with<F>( self, _: &mut F, ) -> Result<AnyImplId, <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) -> AnyImplId

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

fn try_fold_with<F>( self, _: &mut F, ) -> Result<EarlyParamRegion, <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) -> EarlyParamRegion

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 AdtDef

fn try_fold_with<F>( self, _: &mut F, ) -> Result<AdtDef, <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) -> AdtDef

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 ScalarInt

fn try_fold_with<F>( self, _: &mut F, ) -> Result<ScalarInt, <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) -> ScalarInt

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

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<StoredTy, <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) -> StoredTy

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

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<StoredTys, <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) -> StoredTys

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 PlaceTy<'db>

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<PlaceTy<'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) -> PlaceTy<'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 SolverDiagnostic

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<SolverDiagnostic, <__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) -> SolverDiagnostic

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 SolverDiagnosticKind

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<SolverDiagnosticKind, <__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) -> SolverDiagnosticKind

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 StoredTraitPredicate

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<StoredTraitPredicate, <__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) -> StoredTraitPredicate

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<'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 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, 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<'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> 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 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 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 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 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 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 Projection

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 Place

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 InferenceDiagnostic

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 StoredFnSig

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 StoredTraitRef

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> TypeVisitable<DbInterner<'db>> for ValTree<'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 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 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 Consts<'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 StoredGenericArg

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

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

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, T> TypeVisitable<DbInterner<'db>> for Obligation<'db, T>

where T: 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 Pattern<'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 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 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 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 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 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 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 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 CoroutineClosureIdWrapper<'_>

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

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 TraitAssocConstId

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 TraitAssocTermId

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 ImplOrTraitAssocTyId

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 ImplOrTraitAssocConstId

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 ImplOrTraitAssocTermId

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 FreeTyAliasId

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 FreeConstAliasId

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 FreeTermAliasId

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 InherentAssocTyId

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 InherentAssocConstId

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 InherentAssocTermId

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 OpaqueTyIdWrapper<'_>

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 AnyImplId

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

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 AdtDef

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 ScalarInt

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

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

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 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 PlaceTy<'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 SolverDiagnostic

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 SolverDiagnosticKind

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 StoredTraitPredicate

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 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> 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 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> 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 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>, 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>, 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 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>, 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>, 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>, 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>, 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>, 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>, 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 Predicate<'db>

fn upcast_from( from: OutlivesPredicate<DbInterner<'db>, Region<'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>, Ty<'db>>> for Predicate<'db>

fn upcast_from( from: OutlivesPredicate<DbInterner<'db>, Ty<'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>, 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 Predicate<'db>

fn upcast_from( from: ProjectionPredicate<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>, TraitPredicate<DbInterner<'db>>> for Predicate<'db>

fn upcast_from( from: TraitPredicate<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>, TraitRef<DbInterner<'db>>> for Predicate<'db>

fn upcast_from( from: TraitRef<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> ValueConst<DbInterner<'db>> for ValueConst<'db>

fn ty(self) -> Ty<'db>

fn valtree(self) -> ValTree<'db>