Struct DbInterner

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

Implementations

impl<'db> DbInterner<'db>

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

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

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

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

Trait Implementations

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

fn rust() -> FnAbi

fn is_rust(self) -> bool

Whether this ABI is extern "Rust".

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

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

fn is_struct(self) -> bool

fn is_phantom_data(self) -> bool

fn is_fundamental(self) -> bool

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

Returns the type of the struct tail.

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

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

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

fn is_manually_drop(self) -> bool

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

fn principal_def_id(self) -> Option<TraitIdWrapper>

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

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

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

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

fn var(self) -> BoundVar

fn assert_eq(self, var: BoundVarKind)

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

fn var(self) -> BoundVar

fn assert_eq(self, var: BoundVarKind)

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

fn var(self) -> BoundVar

fn assert_eq(self, var: BoundVarKind)

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

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

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

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

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

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

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

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

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

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

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

fn new_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_placeholder( interner: DbInterner<'db>, param: <DbInterner<'db> as Interner>::PlaceholderConst, ) -> Const<'db>

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

fn is_ct_var(self) -> bool

fn is_ct_error(self) -> bool

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

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

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

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

Formats the value using the given formatter.

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

fn as_local(self) -> Option<SolverDefId>

fn is_local(self) -> bool

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

fn as_local(self) -> Option<SolverDefId>

fn is_local(self) -> bool

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

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

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

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

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

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

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

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

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

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

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

fn generic_const_exprs(self) -> bool

fn coroutine_clone(self) -> bool

fn associated_const_equality(self) -> bool

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

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

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

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

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

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

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

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

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

fn is_non_region_infer(self) -> bool

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn count(&self) -> usize

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

fn data_layout(&self) -> &TargetDataLayout

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

type DefId = SolverDefId

type LocalDefId = SolverDefId

type LocalDefIds = SolverDefIds

type TraitId = TraitIdWrapper

A DefId of a trait.

type Span = Span

type GenericArgs = GenericArgs<'db>

type GenericArgsSlice = GenericArgs<'db>

type GenericArg = GenericArg<'db>

type Term = Term<'db>

type BoundVarKinds = BoundVarKinds

type BoundVarKind = BoundVarKind

type PredefinedOpaques = PredefinedOpaques<'db>

type CanonicalVarKinds = CanonicalVars<'db>

type ExternalConstraints = ExternalConstraints<'db>

type DepNodeIndex = DepNodeIndex

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

type Ty = Ty<'db>

type Tys = Tys<'db>

type FnInputTys = Tys<'db>

type ParamTy = ParamTy

type BoundTy = BoundTy

type PlaceholderTy = Placeholder<BoundTy>

type Symbol = ()

type ErrorGuaranteed = ErrorGuaranteed

type BoundExistentialPredicates = BoundExistentialPredicates<'db>

type AllocId = AllocId

type Pat = Pattern<'db>

type PatList = PatList<'db>

type Safety = Safety

type Abi = FnAbi

type Const = Const<'db>

type PlaceholderConst = Placeholder<BoundConst>

type ParamConst = ParamConst

type BoundConst = BoundConst

type ValueConst = ValueConst<'db>

type ValTree = Valtree<'db>

type ExprConst = ExprConst

type Region = Region<'db>

type EarlyParamRegion = EarlyParamRegion

type LateParamRegion = LateParamRegion

type BoundRegion = BoundRegion

type PlaceholderRegion = Placeholder<BoundRegion>

type RegionAssumptions = RegionAssumptions<'db>

type ParamEnv = ParamEnv<'db>

type Predicate = Predicate<'db>

type Clause = Clause<'db>

type Clauses = Clauses<'db>

type GenericsOf = Generics

type VariancesOf = VariancesOf

type AdtDef = AdtDef

type Features = Features

type UnsizingParams = UnsizingParams

type Probe = Probe<DbInterner<'db>>

fn mk_predefined_opaques_in_body( self, data: PredefinedOpaquesData<DbInterner<'db>>, ) -> <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 evaluation_is_concurrent(&self) -> bool

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, adt_def_id: <DbInterner<'db> as Interner>::DefId, ) -> <DbInterner<'db> as Interner>::AdtDef

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

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

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

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

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

fn debug_assert_existential_args_compatible( self, def_id: <DbInterner<'db> as Interner>::DefId, args: <DbInterner<'db> as Interner>::GenericArgs, )

Assert that the args from an ExistentialTraitRef or ExistentialProjection are compatible with the DefId.

fn mk_type_list_from_iter<I, T>( self, args: I, ) -> <T as CollectAndApply<<DbInterner<'db> as Interner>::Ty, <DbInterner<'db> as Interner>::Tys>>::Output

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

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

fn recursion_limit(self) -> usize

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

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

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

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

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_def_id: <DbInterner<'db> as Interner>::DefId, ) -> 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>::DefId, ) -> bool

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn unsizing_params_for_adt( self, adt_def_id: <DbInterner<'db> as Interner>::DefId, ) -> <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, defining_anchor: <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, def_id: <DbInterner<'db> as Interner>::DefId) -> bool

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

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

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

fn coroutine_hidden_types( self, def_id: <DbInterner<'db> as Interner>::DefId, ) -> 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>::DefId, ) -> bool

fn impl_specializes( self, impl_def_id: <DbInterner<'db> as Interner>::DefId, victim_def_id: <DbInterner<'db> as Interner>::DefId, ) -> bool

fn next_trait_solver_globally(self) -> bool

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

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type Bound = BoundConst

fn universe(self) -> UniverseIndex

fn var(self) -> BoundVar

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

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

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

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

type Bound = BoundRegion

fn universe(self) -> UniverseIndex

fn var(self) -> BoundVar

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

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

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

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

type Bound = BoundTy

fn universe(self) -> UniverseIndex

fn var(self) -> BoundVar

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

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

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

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

fn allow_normalization(self) -> bool

Whether this projection can be soundly normalized.

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

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

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

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

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

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

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

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

fn is_bound(self) -> bool

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn safe() -> Safety

fn is_safe(self) -> bool

fn prefix_str(self) -> &'static str

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

fn dummy() -> Span

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

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

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

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

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

fn is_infer(self) -> bool

fn is_error(self) -> bool

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn new_coroutine_witness_for_coroutine( interner: DbInterner<'db>, def_id: <DbInterner<'db> as Interner>::DefId, 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: <DbInterner<'db> as Interner>::DefId, 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 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 discriminant_ty( self, interner: DbInterner<'db>, ) -> <DbInterner<'db> as Interner>::Ty

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

fn has_unsafe_fields(self) -> bool

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

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

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

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

fn is_ty_var(self) -> bool

fn is_ty_error(self) -> bool

fn is_floating_point(self) -> bool

fn is_integral(self) -> bool

fn is_fn_ptr(self) -> bool

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

fn is_known_rigid(self) -> bool

fn is_guaranteed_unsized_raw(self) -> bool

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn fold_with<F>(self, folder: &mut F) -> ExprConst

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn 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).

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

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

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

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

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

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

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

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

where T: TypeFoldable<I>,

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

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

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

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

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

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

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

where T: TypeFoldable<I>,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'db> TypeVisitable<DbInterner<'db>> for 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 ErrorGuaranteed

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'db> TypeVisitor<DbInterner<'db>> for ContainsTypeErrors

type Result = ControlFlow<()>

fn visit_ty( &mut self, t: Ty<'db>, ) -> <ContainsTypeErrors as TypeVisitor<DbInterner<'db>>>::Result

fn visit_binder<T>(&mut self, t: &Binder<I, T>) -> Self::Result

where T: TypeVisitable<I>,

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

fn visit_const(&mut self, c: <I as Interner>::Const) -> Self::Result

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

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

fn visit_error( &mut self, _guar: <I as Interner>::ErrorGuaranteed, ) -> Self::Result

impl<'db> TypeVisitor<DbInterner<'db>> for MaxUniverse

type Result = ()

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

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

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

fn visit_binder<T>(&mut self, t: &Binder<I, T>) -> Self::Result

where T: TypeVisitable<I>,

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

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

fn visit_error( &mut self, _guar: <I as Interner>::ErrorGuaranteed, ) -> Self::Result

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

fn inputs(self) -> <DbInterner<'db> as Interner>::FnInputTys

fn output(self) -> <DbInterner<'db> as Interner>::Ty

impl<'db> UpcastFrom<DbInterner<'db>, Binder<DbInterner<'db>, ClauseKind<DbInterner<'db>>>> for Clause<'db>

fn upcast_from( from: Binder<DbInterner<'db>, ClauseKind<DbInterner<'db>>>, interner: DbInterner<'db>, ) -> Clause<'db>

impl<'db> UpcastFrom<DbInterner<'db>, Binder<DbInterner<'db>, ClauseKind<DbInterner<'db>>>> for Predicate<'db>

fn upcast_from( from: Binder<DbInterner<'db>, ClauseKind<DbInterner<'db>>>, interner: DbInterner<'db>, ) -> Predicate<'db>

impl<'db> UpcastFrom<DbInterner<'db>, Binder<DbInterner<'db>, PredicateKind<DbInterner<'db>>>> for Predicate<'db>

fn upcast_from( from: Binder<DbInterner<'db>, PredicateKind<DbInterner<'db>>>, interner: DbInterner<'db>, ) -> Predicate<'db>

impl<'db> UpcastFrom<DbInterner<'db>, Binder<DbInterner<'db>, ProjectionPredicate<DbInterner<'db>>>> for Clause<'db>

fn upcast_from( from: Binder<DbInterner<'db>, ProjectionPredicate<DbInterner<'db>>>, interner: DbInterner<'db>, ) -> Clause<'db>

impl<'db> UpcastFrom<DbInterner<'db>, Binder<DbInterner<'db>, ProjectionPredicate<DbInterner<'db>>>> for Predicate<'db>

fn upcast_from( from: Binder<DbInterner<'db>, ProjectionPredicate<DbInterner<'db>>>, interner: DbInterner<'db>, ) -> Predicate<'db>

impl<'db> UpcastFrom<DbInterner<'db>, Binder<DbInterner<'db>, TraitPredicate<DbInterner<'db>>>> for Clause<'db>

fn upcast_from( from: Binder<DbInterner<'db>, TraitPredicate<DbInterner<'db>>>, interner: DbInterner<'db>, ) -> Clause<'db>

impl<'db> UpcastFrom<DbInterner<'db>, Binder<DbInterner<'db>, TraitPredicate<DbInterner<'db>>>> for Predicate<'db>

fn upcast_from( from: Binder<DbInterner<'db>, TraitPredicate<DbInterner<'db>>>, interner: DbInterner<'db>, ) -> Predicate<'db>

impl<'db> UpcastFrom<DbInterner<'db>, Binder<DbInterner<'db>, TraitRef<DbInterner<'db>>>> for Clause<'db>

fn upcast_from( from: Binder<DbInterner<'db>, TraitRef<DbInterner<'db>>>, interner: DbInterner<'db>, ) -> Clause<'db>

impl<'db> UpcastFrom<DbInterner<'db>, Binder<DbInterner<'db>, TraitRef<DbInterner<'db>>>> for Predicate<'db>

fn upcast_from( from: Binder<DbInterner<'db>, TraitRef<DbInterner<'db>>>, interner: DbInterner<'db>, ) -> Predicate<'db>

impl<'db> UpcastFrom<DbInterner<'db>, Clause<'db>> for Predicate<'db>

fn upcast_from(from: Clause<'db>, _interner: DbInterner<'db>) -> Predicate<'db>

impl<'db> UpcastFrom<DbInterner<'db>, ClauseKind<DbInterner<'db>>> for Predicate<'db>

fn upcast_from( from: ClauseKind<DbInterner<'db>>, interner: DbInterner<'db>, ) -> Predicate<'db>

impl<'db> UpcastFrom<DbInterner<'db>, NormalizesTo<DbInterner<'db>>> for Predicate<'db>

fn upcast_from( from: NormalizesTo<DbInterner<'db>>, interner: DbInterner<'db>, ) -> Predicate<'db>

impl<'db> UpcastFrom<DbInterner<'db>, OutlivesPredicate<DbInterner<'db>, Region<'db>>> for Predicate<'db>

fn upcast_from( from: OutlivesPredicate<DbInterner<'db>, Region<'db>>, interner: DbInterner<'db>, ) -> Predicate<'db>

impl<'db> UpcastFrom<DbInterner<'db>, OutlivesPredicate<DbInterner<'db>, Ty<'db>>> for Predicate<'db>

fn upcast_from( from: OutlivesPredicate<DbInterner<'db>, Ty<'db>>, interner: DbInterner<'db>, ) -> Predicate<'db>

impl<'db> UpcastFrom<DbInterner<'db>, PredicateKind<DbInterner<'db>>> for Predicate<'db>

fn upcast_from( from: PredicateKind<DbInterner<'db>>, interner: DbInterner<'db>, ) -> Predicate<'db>

impl<'db> UpcastFrom<DbInterner<'db>, ProjectionPredicate<DbInterner<'db>>> for Clause<'db>

fn upcast_from( from: ProjectionPredicate<DbInterner<'db>>, interner: DbInterner<'db>, ) -> Clause<'db>

impl<'db> UpcastFrom<DbInterner<'db>, ProjectionPredicate<DbInterner<'db>>> for Predicate<'db>

fn upcast_from( from: ProjectionPredicate<DbInterner<'db>>, interner: DbInterner<'db>, ) -> Predicate<'db>

impl<'db> UpcastFrom<DbInterner<'db>, TraitPredicate<DbInterner<'db>>> for Clause<'db>

fn upcast_from( from: TraitPredicate<DbInterner<'db>>, interner: DbInterner<'db>, ) -> Clause<'db>

impl<'db> UpcastFrom<DbInterner<'db>, TraitPredicate<DbInterner<'db>>> for Predicate<'db>

fn upcast_from( from: TraitPredicate<DbInterner<'db>>, interner: DbInterner<'db>, ) -> Predicate<'db>

impl<'db> UpcastFrom<DbInterner<'db>, TraitRef<DbInterner<'db>>> for Clause<'db>

fn upcast_from( from: TraitRef<DbInterner<'db>>, interner: DbInterner<'db>, ) -> Clause<'db>

impl<'db> UpcastFrom<DbInterner<'db>, TraitRef<DbInterner<'db>>> for Predicate<'db>

fn upcast_from( from: TraitRef<DbInterner<'db>>, interner: DbInterner<'db>, ) -> Predicate<'db>

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

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

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

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

impl<'db> Copy for DbInterner<'db>

impl Send for DbInterner<'_>

impl Sync for DbInterner<'_>