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, krate: Option<Crate>, block: Option<BlockId>, ) -> DbInterner<'db>

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

impl<'db> DbInterner<'db>

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

where T: TypeFoldable<Self>,

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

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

Trait Implementations

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

fn rust() -> Self

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<<DbInterner<'db> as Interner>::DefId>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type ParamConst = ParamConst

type BoundConst = BoundVar

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

fn mk_predefined_opaques_in_body( self, data: PredefinedOpaquesData<Self>, ) -> Self::PredefinedOpaques

fn mk_canonical_var_kinds( self, kinds: &[CanonicalVarKind<Self>], ) -> Self::CanonicalVarKinds

fn mk_external_constraints( self, data: ExternalConstraintsData<Self>, ) -> Self::ExternalConstraints

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

fn mk_args_from_iter<I, T>(self, args: I) -> T::Output

where I: Iterator<Item = T>, T: CollectAndApply<Self::GenericArg, Self::GenericArgs>,

fn mk_tracked<T: Debug + Clone>( self, data: T, dep_node: Self::DepNodeIndex, ) -> Self::Tracked<T>

fn get_tracked<T: Debug + Clone>(self, tracked: &Self::Tracked<T>) -> T

fn with_cached_task<T>( self, task: impl FnOnce() -> T, ) -> (T, Self::DepNodeIndex)

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

fn canonical_param_env_cache_get_or_insert<R>( self, param_env: Self::ParamEnv, f: impl FnOnce() -> CanonicalParamEnvCacheEntry<Self>, from_entry: impl FnOnce(&CanonicalParamEnvCacheEntry<Self>) -> R, ) -> R

fn evaluation_is_concurrent(&self) -> bool

fn expand_abstract_consts<T: TypeFoldable<Self>>(self, _: T) -> T

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

fn variances_of(self, def_id: Self::DefId) -> Self::VariancesOf

fn type_of(self, def_id: Self::DefId) -> EarlyBinder<Self, Self::Ty>

fn adt_def(self, adt_def_id: Self::DefId) -> Self::AdtDef

fn alias_ty_kind(self, alias: AliasTy<Self>) -> AliasTyKind

fn alias_term_kind(self, alias: AliasTerm<Self>) -> AliasTermKind

fn trait_ref_and_own_args_for_alias( self, def_id: Self::DefId, args: Self::GenericArgs, ) -> (TraitRef<Self>, Self::GenericArgsSlice)

fn check_args_compatible( self, def_id: Self::DefId, args: Self::GenericArgs, ) -> bool

fn debug_assert_args_compatible( self, def_id: Self::DefId, args: Self::GenericArgs, )

fn debug_assert_existential_args_compatible( self, def_id: Self::DefId, args: Self::GenericArgs, )

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

fn mk_type_list_from_iter<I, T>(self, args: I) -> T::Output

where I: Iterator<Item = T>, T: CollectAndApply<Self::Ty, Self::Tys>,

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

fn recursion_limit(self) -> usize

fn features(self) -> Self::Features

fn fn_sig( self, def_id: Self::DefId, ) -> EarlyBinder<Self, Binder<Self, FnSig<Self>>>

fn coroutine_movability(self, def_id: Self::DefId) -> Movability

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

fn generics_require_sized_self(self, def_id: Self::DefId) -> bool

fn item_bounds( self, def_id: Self::DefId, ) -> EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>>

fn item_self_bounds( self, def_id: Self::DefId, ) -> EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>>

fn item_non_self_bounds( self, def_id: Self::DefId, ) -> EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>>

fn predicates_of( self, def_id: Self::DefId, ) -> EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>>

fn own_predicates_of( self, def_id: Self::DefId, ) -> EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>>

fn explicit_super_predicates_of( self, def_id: Self::DefId, ) -> EarlyBinder<Self, impl IntoIterator<Item = (Self::Clause, Self::Span)>>

fn explicit_implied_predicates_of( self, def_id: Self::DefId, ) -> EarlyBinder<Self, impl IntoIterator<Item = (Self::Clause, Self::Span)>>

fn impl_super_outlives( self, impl_def_id: Self::DefId, ) -> EarlyBinder<Self, impl IntoIterator<Item = Self::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: Self::DefId, ) -> EarlyBinder<Self, impl IntoIterator<Item = Binder<Self, TraitRef<Self>>>>

fn has_target_features(self, def_id: Self::DefId) -> bool

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

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

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

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

fn for_each_relevant_impl( self, trait_def_id: Self::DefId, self_ty: Self::Ty, f: impl FnMut(Self::DefId), )

fn has_item_definition(self, def_id: Self::DefId) -> bool

fn impl_is_default(self, impl_def_id: Self::DefId) -> bool

fn impl_trait_ref( self, impl_def_id: Self::DefId, ) -> EarlyBinder<Self, TraitRef<Self>>

fn impl_polarity(self, impl_def_id: Self::DefId) -> ImplPolarity

fn trait_is_auto(self, trait_def_id: Self::DefId) -> bool

fn trait_is_alias(self, trait_def_id: Self::DefId) -> bool

fn trait_is_dyn_compatible(self, trait_def_id: Self::DefId) -> bool

fn trait_is_fundamental(self, def_id: Self::DefId) -> bool

fn trait_may_be_implemented_via_object(self, trait_def_id: Self::DefId) -> bool

fn is_impl_trait_in_trait(self, def_id: Self::DefId) -> bool

fn delay_bug(self, msg: impl ToString) -> Self::ErrorGuaranteed

fn is_general_coroutine(self, coroutine_def_id: Self::DefId) -> bool

fn coroutine_is_async(self, coroutine_def_id: Self::DefId) -> bool

fn coroutine_is_gen(self, coroutine_def_id: Self::DefId) -> bool

fn coroutine_is_async_gen(self, coroutine_def_id: Self::DefId) -> bool

fn unsizing_params_for_adt( self, adt_def_id: Self::DefId, ) -> Self::UnsizingParams

fn anonymize_bound_vars<T: TypeFoldable<Self>>( self, value: Binder<Self, T>, ) -> Binder<Self, T>

fn opaque_types_defined_by( self, defining_anchor: Self::LocalDefId, ) -> Self::LocalDefIds

fn alias_has_const_conditions(self, def_id: Self::DefId) -> bool

fn explicit_implied_const_bounds( self, def_id: Self::DefId, ) -> EarlyBinder<Self, impl IntoIterator<Item = Binder<Self, TraitRef<Self>>>>

fn fn_is_const(self, def_id: Self::DefId) -> bool

fn impl_is_const(self, def_id: Self::DefId) -> bool

fn opt_alias_variances( self, kind: impl Into<AliasTermKind>, def_id: Self::DefId, ) -> Option<Self::VariancesOf>

fn type_of_opaque_hir_typeck( self, def_id: Self::LocalDefId, ) -> EarlyBinder<Self, Self::Ty>

fn coroutine_hidden_types( self, def_id: Self::DefId, ) -> EarlyBinder<Self, Binder<Self, CoroutineWitnessTypes<Self>>>

fn is_default_trait(self, def_id: Self::DefId) -> bool

fn trait_is_coinductive(self, trait_def_id: Self::DefId) -> bool

fn trait_is_unsafe(self, trait_def_id: Self::DefId) -> bool

Returns true if this is an unsafe trait.

fn impl_self_is_guaranteed_unsized(self, def_id: Self::DefId) -> bool

fn impl_specializes( self, impl_def_id: Self::DefId, victim_def_id: Self::DefId, ) -> bool

fn next_trait_solver_globally(self) -> bool

fn opaque_types_and_coroutines_defined_by( self, defining_anchor: Self::LocalDefId, ) -> Self::LocalDefIds

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'db> PlaceholderLike<DbInterner<'db>> for PlaceholderRegion

type Bound = BoundRegion

fn universe(self) -> UniverseIndex

fn var(self) -> BoundVar

fn with_updated_universe(self, ui: UniverseIndex) -> Self

fn new(ui: UniverseIndex, bound: Self::Bound) -> Self

fn new_anon(ui: UniverseIndex, var: BoundVar) -> Self

impl<'db> PlaceholderLike<DbInterner<'db>> for PlaceholderTy

type Bound = BoundTy

fn universe(self) -> UniverseIndex

fn var(self) -> BoundVar

fn with_updated_universe(self, ui: UniverseIndex) -> Self

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

fn new_anon(ui: UniverseIndex, var: BoundVar) -> Self

impl<'db> PlaceholderLike<DbInterner<'db>> for PlaceholderConst

type Bound = BoundVar

fn universe(self) -> UniverseIndex

fn var(self) -> BoundVar

fn with_updated_universe(self, ui: UniverseIndex) -> Self

fn new(ui: UniverseIndex, var: BoundVar) -> Self

fn new_anon(ui: UniverseIndex, var: BoundVar) -> Self

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

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

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

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

fn is_bound(self) -> bool

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

fn relate<R: TypeRelation<DbInterner<'db>>>( relation: &mut R, a: Self, b: Self, ) -> RelateResult<DbInterner<'db>, Self>

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

fn relate<R: TypeRelation<DbInterner<'db>>>( relation: &mut R, a: Self, b: Self, ) -> RelateResult<DbInterner<'db>, Self>

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

fn relate<R: TypeRelation<DbInterner<'db>>>( relation: &mut R, a: Self, b: Self, ) -> RelateResult<DbInterner<'db>, Self>

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

fn relate<R: TypeRelation<DbInterner<'db>>>( _relation: &mut R, a: Self, b: Self, ) -> RelateResult<DbInterner<'db>, Self>

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

fn relate<R: TypeRelation<DbInterner<'db>>>( relation: &mut R, a: Self, b: Self, ) -> RelateResult<DbInterner<'db>, Self>

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

fn relate<R: TypeRelation<DbInterner<'db>>>( relation: &mut R, a: Self, b: Self, ) -> RelateResult<DbInterner<'db>, Self>

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

fn relate<R: TypeRelation<DbInterner<'db>>>( relation: &mut R, a: Self, b: Self, ) -> RelateResult<DbInterner<'db>, Self>

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

fn relate<R: TypeRelation<DbInterner<'db>>>( relation: &mut R, a: Self, b: Self, ) -> RelateResult<DbInterner<'db>, Self>

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

fn relate<R: TypeRelation<DbInterner<'db>>>( _relation: &mut R, a: Self, b: Self, ) -> RelateResult<DbInterner<'db>, Self>

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

fn relate<R: TypeRelation<DbInterner<'db>>>( relation: &mut R, a: Self, b: Self, ) -> RelateResult<DbInterner<'db>, Self>

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

fn relate<R: TypeRelation<DbInterner<'db>>>( relation: &mut R, a: Self, b: Self, ) -> RelateResult<DbInterner<'db>, Self>

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

fn safe() -> Self

fn is_safe(self) -> bool

fn prefix_str(self) -> &'static str

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

fn dummy() -> Self

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

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

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

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

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

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

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

fn new_placeholder(interner: DbInterner<'db>, param: PlaceholderTy) -> Self

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

where It: Iterator<Item = T>, T: CollectAndApply<Self, Self>,

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

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

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

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

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

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

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: FallibleTypeFolder<DbInterner<'db>>>( self, folder: &mut F, ) -> Result<Self, F::Error>

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

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

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: FallibleTypeFolder<DbInterner<'db>>>( self, _: &mut F, ) -> Result<Self, F::Error>

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

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

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 BoundVar

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

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

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

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: FallibleTypeFolder<DbInterner<'db>>>( self, folder: &mut F, ) -> Result<Self, F::Error>

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

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

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: FallibleTypeFolder<DbInterner<'db>>>( self, folder: &mut F, ) -> Result<Self, F::Error>

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

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

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: FallibleTypeFolder<DbInterner<'db>>>( self, folder: &mut F, ) -> Result<Self, F::Error>

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

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

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: FallibleTypeFolder<DbInterner<'db>>>( self, folder: &mut F, ) -> Result<Self, F::Error>

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

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

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: FallibleTypeFolder<DbInterner<'db>>>( self, folder: &mut F, ) -> Result<Self, F::Error>

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

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

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: FallibleTypeFolder<DbInterner<'db>>>( self, folder: &mut F, ) -> Result<Self, F::Error>

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

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

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: FallibleTypeFolder<DbInterner<'db>>>( self, _: &mut F, ) -> Result<Self, F::Error>

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

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

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: FallibleTypeFolder<DbInterner<'db>>>( self, folder: &mut F, ) -> Result<Self, F::Error>

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

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

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: FallibleTypeFolder<DbInterner<'db>>>( self, folder: &mut F, ) -> Result<Self, F::Error>

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

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

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: FallibleTypeFolder<DbInterner<'db>>>( self, _: &mut F, ) -> Result<Self, F::Error>

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

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

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: FallibleTypeFolder<DbInterner<'db>>>( self, folder: &mut F, ) -> Result<Self, F::Error>

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

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

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: FallibleTypeFolder<DbInterner<'db>>>( self, _: &mut F, ) -> Result<Self, F::Error>

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

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

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: FallibleTypeFolder<DbInterner<'db>>>( self, folder: &mut F, ) -> Result<Self, F::Error>

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

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

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: FallibleTypeFolder<DbInterner<'db>>>( self, _: &mut F, ) -> Result<Self, F::Error>

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

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

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: FallibleTypeFolder<DbInterner<'db>>>( self, _: &mut F, ) -> Result<Self, F::Error>

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

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

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: FallibleTypeFolder<DbInterner<'db>>>( self, _: &mut F, ) -> Result<Self, F::Error>

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

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

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: FallibleTypeFolder<DbInterner<'db>>>( self, _: &mut F, ) -> Result<Self, F::Error>

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

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

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: FallibleTypeFolder<DbInterner<'db>>>( self, folder: &mut F, ) -> Result<Self, F::Error>

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

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

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: FallibleTypeFolder<DbInterner<'db>>>( self, folder: &mut F, ) -> Result<Self, F::Error>

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

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

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: FallibleTypeFolder<DbInterner<'db>>>( self, folder: &mut F, ) -> Result<Self, F::Error>

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

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

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: FallibleTypeFolder<DbInterner<'db>>>( self, folder: &mut F, ) -> Result<Self, F::Error>

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

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

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: FallibleTypeFolder<DbInterner<'db>>>( self, _: &mut F, ) -> Result<Self, F::Error>

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

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

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: FallibleTypeFolder<DbInterner<'db>>>( self, _: &mut F, ) -> Result<Self, F::Error>

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

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

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: FallibleTypeFolder<DbInterner<'db>>>( self, folder: &mut F, ) -> Result<Self, F::Error>

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

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

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: FallibleTypeFolder<DbInterner<'db>>>( self, _: &mut F, ) -> Result<Self, F::Error>

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

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

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: FallibleTypeFolder<DbInterner<'db>>>( self, folder: &mut F, ) -> Result<Self, F::Error>

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

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

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: FallibleTypeFolder<DbInterner<'db>>>( self, folder: &mut F, ) -> Result<Self, F::Error>

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

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

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: FallibleTypeFolder<DbInterner<'db>>>( self, folder: &mut F, ) -> Result<Self, F::Error>

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

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

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: TypeFolder<DbInterner<'db>>>(self, folder: &mut F) -> Self

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

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

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: TypeFoldable<DbInterner<'db>>>( &mut self, t: Binder<'db, T>, ) -> Binder<'db, T>

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: FallibleTypeFolder<DbInterner<'db>>>( self, folder: &mut F, ) -> Result<Self, F::Error>

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: TypeFolder<DbInterner<'db>>>(self, folder: &mut F) -> Self

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: FallibleTypeFolder<DbInterner<'db>>>( self, folder: &mut F, ) -> Result<Self, F::Error>

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: TypeFolder<DbInterner<'db>>>(self, folder: &mut F) -> Self

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: FallibleTypeFolder<DbInterner<'db>>>( self, folder: &mut F, ) -> Result<Self, F::Error>

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: TypeFolder<DbInterner<'db>>>(self, folder: &mut F) -> Self

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: FallibleTypeFolder<DbInterner<'db>>>( self, folder: &mut F, ) -> Result<Self, F::Error>

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: TypeFolder<DbInterner<'db>>>(self, folder: &mut F) -> Self

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: TypeVisitor<DbInterner<'db>>>( &self, visitor: &mut V, ) -> V::Result

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: TypeVisitor<DbInterner<'db>>>( &self, visitor: &mut V, ) -> V::Result

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: TypeVisitor<DbInterner<'db>>>( &self, visitor: &mut V, ) -> V::Result

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: TypeVisitor<DbInterner<'db>>>( &self, visitor: &mut V, ) -> V::Result

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: TypeVisitor<DbInterner<'db>>>( &self, visitor: &mut V, ) -> V::Result

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: TypeVisitor<DbInterner<'db>>>(&self, _: &mut F) -> F::Result

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 BoundVar

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

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: TypeVisitor<DbInterner<'db>>>( &self, visitor: &mut V, ) -> V::Result

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: TypeVisitor<DbInterner<'db>>>( &self, visitor: &mut V, ) -> V::Result

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: TypeVisitor<DbInterner<'db>>>( &self, visitor: &mut V, ) -> V::Result

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: TypeVisitor<DbInterner<'db>>>( &self, visitor: &mut V, ) -> V::Result

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: TypeVisitor<DbInterner<'db>>>( &self, visitor: &mut V, ) -> V::Result

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: TypeVisitor<DbInterner<'db>>>( &self, visitor: &mut V, ) -> V::Result

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: TypeVisitor<DbInterner<'db>>>(&self, _: &mut F) -> F::Result

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: TypeVisitor<DbInterner<'db>>>( &self, visitor: &mut V, ) -> V::Result

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: TypeVisitor<DbInterner<'db>>>( &self, visitor: &mut V, ) -> V::Result

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: TypeVisitor<DbInterner<'db>>>(&self, _: &mut F) -> F::Result

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: TypeVisitor<DbInterner<'db>>>( &self, visitor: &mut V, ) -> V::Result

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: TypeVisitor<DbInterner<'db>>>(&self, _: &mut F) -> F::Result

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: TypeVisitor<DbInterner<'db>>>( &self, visitor: &mut V, ) -> V::Result

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: TypeVisitor<DbInterner<'db>>>(&self, _: &mut F) -> F::Result

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: TypeVisitor<DbInterner<'db>>>(&self, _: &mut F) -> F::Result

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: TypeVisitor<DbInterner<'db>>>(&self, _: &mut F) -> F::Result

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: TypeVisitor<DbInterner<'db>>>(&self, _: &mut F) -> F::Result

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: TypeVisitor<DbInterner<'db>>>( &self, visitor: &mut V, ) -> V::Result

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: TypeVisitor<DbInterner<'db>>>( &self, visitor: &mut V, ) -> V::Result

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: TypeVisitor<DbInterner<'db>>>( &self, visitor: &mut V, ) -> V::Result

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: TypeVisitor<DbInterner<'db>>>( &self, visitor: &mut V, ) -> V::Result

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: TypeVisitor<DbInterner<'db>>>(&self, _: &mut F) -> F::Result

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: TypeVisitor<DbInterner<'db>>>(&self, _: &mut F) -> F::Result

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: TypeVisitor<DbInterner<'db>>>( &self, visitor: &mut V, ) -> V::Result

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: TypeVisitor<DbInterner<'db>>>(&self, _: &mut F) -> F::Result

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: TypeVisitor<DbInterner<'db>>>( &self, visitor: &mut V, ) -> V::Result

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: TypeVisitor<DbInterner<'db>>>( &self, visitor: &mut V, ) -> V::Result

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: TypeVisitor<DbInterner<'db>>>( &self, visitor: &mut V, ) -> V::Result

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: TypeVisitor<DbInterner<'db>>>( &self, visitor: &mut V, ) -> V::Result

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>) -> Self::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>, ) -> Self

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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