Struct ChalkTyInterner

pub struct ChalkTyInterner;

Trait Implementations

impl Clone for Interner

fn clone(&self) -> Interner

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Interner

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

Formats the value using the given formatter.

impl HasInterner for Interner

type Interner = Interner

The interner associated with the type.

impl Hash for Interner

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Interner for Interner

type InternedType = Interned<InternedWrapper<TyData<Interner>>>

“Interned” representation of types. In normal user code, Self::InternedType is not referenced. Instead, we refer to Ty<Self>, which wraps this type.

type InternedLifetime = Interned<InternedWrapper<LifetimeData<Interner>>>

“Interned” representation of lifetimes. In normal user code, Self::InternedLifetime is not referenced. Instead, we refer to Lifetime<Self>, which wraps this type.

type InternedConst = Interned<InternedWrapper<ConstData<Interner>>>

“Interned” representation of const expressions. In normal user code, Self::InternedConst is not referenced. Instead, we refer to Const<Self>, which wraps this type.

type InternedConcreteConst = ConstScalar

“Interned” representation of an evaluated const value. Self::InternedConcreteConst is not referenced. Instead, we refer to ConcreteConst<Self>, which wraps this type.

type InternedGenericArg = GenericArgData<Interner>

“Interned” representation of a “generic parameter”, which can be either a type or a lifetime. In normal user code, Self::InternedGenericArg is not referenced. Instead, we refer to GenericArg<Self>, which wraps this type.

type InternedGoal = Arc<GoalData<Interner>>

“Interned” representation of a “goal”. In normal user code, Self::InternedGoal is not referenced. Instead, we refer to Goal<Self>, which wraps this type.

type InternedGoals = Vec<Goal<Interner>>

“Interned” representation of a list of goals. In normal user code, Self::InternedGoals is not referenced. Instead, we refer to Goals<Self>, which wraps this type.

type InternedSubstitution = Interned<InternedWrapper<SmallVec<[GenericArg<Interner>; 2]>>>

“Interned” representation of a “substitution”. In normal user code, Self::InternedSubstitution is not referenced. Instead, we refer to Substitution<Self>, which wraps this type.

type InternedProgramClauses = Interned<InternedWrapper<Vec<ProgramClause<Interner>>>>

“Interned” representation of a list of program clauses. In normal user code, Self::InternedProgramClauses is not referenced. Instead, we refer to ProgramClauses<Self>, which wraps this type.

type InternedProgramClause = ProgramClauseData<Interner>

“Interned” representation of a “program clause”. In normal user code, Self::InternedProgramClause is not referenced. Instead, we refer to ProgramClause<Self>, which wraps this type.

type InternedQuantifiedWhereClauses = Interned<InternedWrapper<Vec<Binders<WhereClause<Interner>>>>>

“Interned” representation of a list of quantified where clauses. In normal user code, Self::InternedQuantifiedWhereClauses is not referenced. Instead, we refer to QuantifiedWhereClauses<Self>, which wraps this type.

type InternedVariableKinds = Interned<InternedWrapper<Vec<VariableKind<Interner>>>>

“Interned” representation of a list of variable kinds. In normal user code, Self::InternedVariableKinds is not referenced. Instead, we refer to VariableKinds<Self>, which wraps this type.

type InternedCanonicalVarKinds = Interned<InternedWrapper<Vec<WithKind<Interner, UniverseIndex>>>>

“Interned” representation of a list of variable kinds with universe index. In normal user code, Self::InternedCanonicalVarKinds is not referenced. Instead, we refer to CanonicalVarKinds<Self>, which wraps this type.

type InternedConstraints = Vec<InEnvironment<Constraint<Interner>>>

“Interned” representation of a list of region constraints. In normal user code, Self::InternedConstraints is not referenced. Instead, we refer to Constraints<Self>, which wraps this type.

type InternedVariances = SmallVec<[Variance; 16]>

“Interned” representation of a list of chalk_ir::Variance. In normal user code, Self::InternedVariances is not referenced. Instead, we refer to Variances<Self>, which wraps this type.

type DefId = InternId

The core “id” type used for trait-ids and the like.

type InternedAdtId = AdtId

The ID type for ADTs

type Identifier = TypeAliasId

Representation of identifiers.

type FnAbi = FnAbi

Representation of function ABI (e.g. calling convention).

fn debug_adt_id( type_kind_id: AdtId<Interner>, fmt: &mut Formatter<'_>, ) -> Option<Result<(), Error>>

Prints the debug representation of a type-kind-id. Returns None to fallback to the default debug output.

fn debug_trait_id( type_kind_id: TraitId<Interner>, fmt: &mut Formatter<'_>, ) -> Option<Result<(), Error>>

Prints the debug representation of a type-kind-id. Returns None to fallback to the default debug output (e.g., if no info about current program is available from TLS).

fn debug_assoc_type_id( id: AssocTypeId<Interner>, fmt: &mut Formatter<'_>, ) -> Option<Result<(), Error>>

Prints the debug representation of a type-kind-id. Returns None to fallback to the default debug output.

fn debug_opaque_ty_id( opaque_ty_id: OpaqueTyId<Interner>, fmt: &mut Formatter<'_>, ) -> Option<Result<(), Error>>

Prints the debug representation of an opaque type. Returns None to fallback to the default debug output.

fn debug_fn_def_id( fn_def_id: FnDefId<Interner>, fmt: &mut Formatter<'_>, ) -> Option<Result<(), Error>>

Prints the debug representation of a function-def-id. Returns None to fallback to the default debug output.

fn debug_closure_id( _fn_def_id: ClosureId<Interner>, _fmt: &mut Formatter<'_>, ) -> Option<Result<(), Error>>

Prints the debug representation of a closure id. Returns None to fallback to the default debug output.

fn debug_alias( alias: &AliasTy<Interner>, fmt: &mut Formatter<'_>, ) -> Option<Result<(), Error>>

Prints the debug representation of an alias. To get good results, this requires inspecting TLS, and is difficult to code without reference to a specific interner (and hence fully known types).

fn debug_projection_ty( proj: &ProjectionTy<Interner>, fmt: &mut Formatter<'_>, ) -> Option<Result<(), Error>>

Prints the debug representation of a ProjectionTy. Returns None to fallback to the default debug output.

fn debug_opaque_ty( opaque_ty: &OpaqueTy<Interner>, fmt: &mut Formatter<'_>, ) -> Option<Result<(), Error>>

Prints the debug representation of an OpaqueTy. Returns None to fallback to the default debug output.

fn debug_ty( ty: &Ty<Interner>, fmt: &mut Formatter<'_>, ) -> Option<Result<(), Error>>

Prints the debug representation of a type. Returns None to fallback to the default debug output.

fn debug_lifetime( lifetime: &Lifetime<Interner>, fmt: &mut Formatter<'_>, ) -> Option<Result<(), Error>>

Prints the debug representation of a lifetime. Returns None to fallback to the default debug output.

fn debug_const( constant: &Const<Interner>, fmt: &mut Formatter<'_>, ) -> Option<Result<(), Error>>

Prints the debug representation of a const. Returns None to fallback to the default debug output.

fn debug_generic_arg( parameter: &GenericArg<Interner>, fmt: &mut Formatter<'_>, ) -> Option<Result<(), Error>>

Prints the debug representation of an parameter. Returns None to fallback to the default debug output.

fn debug_variable_kinds( variable_kinds: &VariableKinds<Interner>, fmt: &mut Formatter<'_>, ) -> Option<Result<(), Error>>

Prints the debug representation of a parameter kinds list. Returns None to fallback to the default debug output.

fn debug_variable_kinds_with_angles( variable_kinds: &VariableKinds<Interner>, fmt: &mut Formatter<'_>, ) -> Option<Result<(), Error>>

Prints the debug representation of a parameter kinds list, with angle brackets. Returns None to fallback to the default debug output.

fn debug_canonical_var_kinds( canonical_var_kinds: &CanonicalVarKinds<Interner>, fmt: &mut Formatter<'_>, ) -> Option<Result<(), Error>>

Prints the debug representation of an parameter kinds list with universe index. Returns None to fallback to the default debug output.

fn debug_goal( goal: &Goal<Interner>, fmt: &mut Formatter<'_>, ) -> Option<Result<(), Error>>

Prints the debug representation of an goal. Returns None to fallback to the default debug output.

fn debug_goals( goals: &Goals<Interner>, fmt: &mut Formatter<'_>, ) -> Option<Result<(), Error>>

Prints the debug representation of a list of goals. Returns None to fallback to the default debug output.

fn debug_program_clause_implication( pci: &ProgramClauseImplication<Interner>, fmt: &mut Formatter<'_>, ) -> Option<Result<(), Error>>

Prints the debug representation of a ProgramClauseImplication. Returns None to fallback to the default debug output.

fn debug_program_clause( clause: &ProgramClause<Interner>, fmt: &mut Formatter<'_>, ) -> Option<Result<(), Error>>

Prints the debug representation of a ProgramClause. Returns None to fallback to the default debug output.

fn debug_program_clauses( clauses: &ProgramClauses<Interner>, fmt: &mut Formatter<'_>, ) -> Option<Result<(), Error>>

Prints the debug representation of a ProgramClauses. Returns None to fallback to the default debug output.

fn debug_substitution( substitution: &Substitution<Interner>, fmt: &mut Formatter<'_>, ) -> Option<Result<(), Error>>

Prints the debug representation of a Substitution. Returns None to fallback to the default debug output.

fn debug_separator_trait_ref( separator_trait_ref: &SeparatorTraitRef<'_, Interner>, fmt: &mut Formatter<'_>, ) -> Option<Result<(), Error>>

Prints the debug representation of a SeparatorTraitRef. Returns None to fallback to the default debug output.

fn debug_quantified_where_clauses( clauses: &QuantifiedWhereClauses<Interner>, fmt: &mut Formatter<'_>, ) -> Option<Result<(), Error>>

Prints the debug representation of a QuantifiedWhereClauses. Returns None to fallback to the default debug output.

fn debug_constraints( _clauses: &Constraints<Interner>, _fmt: &mut Formatter<'_>, ) -> Option<Result<(), Error>>

Prints the debug representation of a Constraints. Returns None to fallback to the default debug output.

fn intern_ty( self, kind: TyKind<Interner>, ) -> <Interner as Interner>::InternedType

Create an “interned” type from ty. This is not normally invoked directly; instead, you invoke TyKind::intern (which will ultimately call this method).

fn ty_data(self, ty: &<Interner as Interner>::InternedType) -> &TyData<Interner>

Lookup the TyKind from an interned type.

fn intern_lifetime( self, lifetime: LifetimeData<Interner>, ) -> <Interner as Interner>::InternedLifetime

Create an “interned” lifetime from lifetime. This is not normally invoked directly; instead, you invoke LifetimeData::intern (which will ultimately call this method).

fn lifetime_data( self, lifetime: &<Interner as Interner>::InternedLifetime, ) -> &LifetimeData<Interner>

Lookup the LifetimeData that was interned to create a InternedLifetime.

fn intern_const( self, constant: ConstData<Interner>, ) -> <Interner as Interner>::InternedConst

Create an “interned” const from const. This is not normally invoked directly; instead, you invoke ConstData::intern (which will ultimately call this method).

fn const_data( self, constant: &<Interner as Interner>::InternedConst, ) -> &ConstData<Interner>

Lookup the ConstData that was interned to create a InternedConst.

fn const_eq( self, _ty: &<Interner as Interner>::InternedType, c1: &<Interner as Interner>::InternedConcreteConst, c2: &<Interner as Interner>::InternedConcreteConst, ) -> bool

Determine whether two concrete const values are equal.

fn intern_generic_arg( self, parameter: GenericArgData<Interner>, ) -> <Interner as Interner>::InternedGenericArg

Create an “interned” parameter from data. This is not normally invoked directly; instead, you invoke GenericArgData::intern (which will ultimately call this method).

fn generic_arg_data( self, parameter: &<Interner as Interner>::InternedGenericArg, ) -> &GenericArgData<Interner>

Lookup the LifetimeData that was interned to create a InternedLifetime.

fn intern_goal( self, goal: GoalData<Interner>, ) -> <Interner as Interner>::InternedGoal

Create an “interned” goal from data. This is not normally invoked directly; instead, you invoke GoalData::intern (which will ultimately call this method).

fn goal_data( self, goal: &<Interner as Interner>::InternedGoal, ) -> &GoalData<Interner>

Lookup the GoalData that was interned to create a InternedGoal.

fn intern_goals<E>( self, data: impl IntoIterator<Item = Result<Goal<Interner>, E>>, ) -> Result<<Interner as Interner>::InternedGoals, E>

Create an “interned” goals from data. This is not normally invoked directly; instead, you invoke GoalsData::intern (which will ultimately call this method).

fn goals_data( self, goals: &<Interner as Interner>::InternedGoals, ) -> &[Goal<Interner>]

Lookup the GoalsData that was interned to create a InternedGoals.

fn intern_substitution<E>( self, data: impl IntoIterator<Item = Result<GenericArg<Interner>, E>>, ) -> Result<<Interner as Interner>::InternedSubstitution, E>

Create an “interned” substitution from data. This is not normally invoked directly; instead, you invoke SubstitutionData::intern (which will ultimately call this method).

fn substitution_data( self, substitution: &<Interner as Interner>::InternedSubstitution, ) -> &[GenericArg<Interner>]

Lookup the SubstitutionData that was interned to create a InternedSubstitution.

fn intern_program_clause( self, data: ProgramClauseData<Interner>, ) -> <Interner as Interner>::InternedProgramClause

Create an “interned” program clause from data. This is not normally invoked directly; instead, you invoke ProgramClauseData::intern (which will ultimately call this method).

fn program_clause_data( self, clause: &<Interner as Interner>::InternedProgramClause, ) -> &ProgramClauseData<Interner>

Lookup the ProgramClauseData that was interned to create a ProgramClause.

fn intern_program_clauses<E>( self, data: impl IntoIterator<Item = Result<ProgramClause<Interner>, E>>, ) -> Result<<Interner as Interner>::InternedProgramClauses, E>

Create an “interned” program clauses from data. This is not normally invoked directly; instead, you invoke ProgramClauses::from_iter (which will ultimately call this method).

fn program_clauses_data( self, clauses: &<Interner as Interner>::InternedProgramClauses, ) -> &[ProgramClause<Interner>]

Lookup the ProgramClauseData that was interned to create a ProgramClause.

fn intern_quantified_where_clauses<E>( self, data: impl IntoIterator<Item = Result<Binders<WhereClause<Interner>>, E>>, ) -> Result<<Interner as Interner>::InternedQuantifiedWhereClauses, E>

Create an “interned” quantified where clauses from data. This is not normally invoked directly; instead, you invoke QuantifiedWhereClauses::from_iter (which will ultimately call this method).

fn quantified_where_clauses_data( self, clauses: &<Interner as Interner>::InternedQuantifiedWhereClauses, ) -> &[Binders<WhereClause<Interner>>]

Lookup the slice of QuantifiedWhereClause that was interned to create a QuantifiedWhereClauses.

fn intern_generic_arg_kinds<E>( self, data: impl IntoIterator<Item = Result<VariableKind<Interner>, E>>, ) -> Result<<Interner as Interner>::InternedVariableKinds, E>

Create an “interned” parameter kinds from data. This is not normally invoked directly; instead, you invoke VariableKinds::from_iter (which will ultimately call this method).

fn variable_kinds_data( self, parameter_kinds: &<Interner as Interner>::InternedVariableKinds, ) -> &[VariableKind<Interner>]

Lookup the slice of VariableKinds that was interned to create a VariableKinds.

fn intern_canonical_var_kinds<E>( self, data: impl IntoIterator<Item = Result<WithKind<Interner, UniverseIndex>, E>>, ) -> Result<<Interner as Interner>::InternedCanonicalVarKinds, E>

Create “interned” variable kinds with universe index from data. This is not normally invoked directly; instead, you invoke CanonicalVarKinds::from_iter (which will ultimately call this method).

fn canonical_var_kinds_data( self, canonical_var_kinds: &<Interner as Interner>::InternedCanonicalVarKinds, ) -> &[WithKind<Interner, UniverseIndex>]

Lookup the slice of CanonicalVariableKind that was interned to create a CanonicalVariableKinds.

fn intern_constraints<E>( self, data: impl IntoIterator<Item = Result<InEnvironment<Constraint<Interner>>, E>>, ) -> Result<<Interner as Interner>::InternedConstraints, E>

Create “interned” constraints from data. This is not normally invoked dirctly; instead, you invoke Constraints::from_iter (which will ultimately call this method).

fn constraints_data( self, constraints: &<Interner as Interner>::InternedConstraints, ) -> &[InEnvironment<Constraint<Interner>>]

Lookup the slice of Constraint that was interned to create a Constraints.

fn intern_variances<E>( self, data: impl IntoIterator<Item = Result<Variance, E>>, ) -> Result<<Interner as Interner>::InternedVariances, E>

Create “interned” variances from data. This is not normally invoked directly; instead, you invoke Variances::from (which will ultimately call this method).

fn variances_data( self, variances: &<Interner as Interner>::InternedVariances, ) -> &[Variance]

Lookup the slice of Variance that was interned to create a Variances.

fn debug_foreign_def_id( foreign_def_id: ForeignDefId<Self>, fmt: &mut Formatter<'_>, ) -> Option<Result<(), Error>>

Prints the debug representation of a foreign-def-id. Returns None to fallback to the default debug output.

fn debug_coroutine_id( coroutine_id: CoroutineId<Self>, fmt: &mut Formatter<'_>, ) -> Option<Result<(), Error>>

Prints the debug representation of an alias. Returns None to fallback to the default debug output.

fn debug_variances( variances: &Variances<Self>, fmt: &mut Formatter<'_>, ) -> Option<Result<(), Error>>

Prints the debug representation of a Variances. Returns None to fallback to the default debug output.

impl Ord for Interner

fn cmp(&self, other: &Interner) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Interner

fn eq(&self, other: &Interner) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Interner

fn partial_cmp(&self, other: &Interner) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl UnificationDatabase<Interner> for &dyn HirDatabase

fn fn_def_variance(&self, fn_def_id: FnDefId<Interner>) -> Variances<Interner>

Gets the variances for the substitution of a fn def

fn adt_variance(&self, adt_id: AdtId<Interner>) -> Variances<Interner>

Gets the variances for the substitution of a adt

impl Copy for Interner

impl Eq for Interner

impl StructuralPartialEq for Interner