Struct ra_ap_hir_ty::Interner

pub struct Interner;

Trait Implementations

impl Clone for Interner

fn clone(&self) -> Interner

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Interner

impl Debug for Interner

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

Formats the value using the given formatter.

impl Eq for Interner

impl HasInterner for Interner

type Interner = Self

The interner associated with the type.

impl Hash for Interner

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl Interner for Interner

type InternedType = Arc<TyData<Self>>

“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 = LifetimeData<Self>

“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 = Arc<ConstData<Self>>

“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 = ()

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

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

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

“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 = SmallVec<[GenericArg<Self>; 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 InternedProgramClause = Arc<ProgramClauseData<Self>>

“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 InternedProgramClauses = Arc<[ProgramClause<Self>]>

“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 InternedQuantifiedWhereClauses = Vec<QuantifiedWhereClause<Self>>

“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 = Vec<VariableKind<Self>>

“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 = Vec<CanonicalVarKind<Self>>

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

“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 = Arc<[Variance]>

“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 = ()

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

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

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>

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>

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

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

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>

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>

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

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

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

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

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>

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

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

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

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

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>

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>

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

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

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>

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

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

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

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

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

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

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<Self>,
    fmt: &mut Formatter<'_>
) -> Option<Result>

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<Self>,
    fmt: &mut Formatter<'_>
) -> Option<Result>

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

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

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

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

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

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

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

fn intern_ty(&self, kind: TyKind<Self>) -> Arc<TyData<Self>>

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<'a>(&self, ty: &'a Arc<TyData<Self>>) -> &'a TyData<Self>

Lookup the TyKind from an interned type.

fn intern_lifetime(&self, lifetime: LifetimeData<Self>) -> LifetimeData<Self>

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<'a>(
    &self,
    lifetime: &'a LifetimeData<Self>
) -> &'a LifetimeData<Self>

Lookup the LifetimeData that was interned to create a InternedLifetime.

fn intern_const(&self, constant: ConstData<Self>) -> Arc<ConstData<Self>>

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<'a>(
    &self,
    constant: &'a Arc<ConstData<Self>>
) -> &'a ConstData<Self>

Lookup the ConstData that was interned to create a InternedConst.

fn const_eq(&self, _ty: &Arc<TyData<Self>>, _c1: &(), _c2: &()) -> bool

Deterermine whether two concrete const values are equal.

fn intern_generic_arg(
    &self,
    parameter: GenericArgData<Self>
) -> GenericArgData<Self>

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<'a>(
    &self,
    parameter: &'a GenericArgData<Self>
) -> &'a GenericArgData<Self>

Lookup the LifetimeData that was interned to create a InternedLifetime.

fn intern_goal(&self, goal: GoalData<Self>) -> Arc<GoalData<Self>>

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

fn intern_goals<E>(
    &self,
    data: impl IntoIterator<Item = Result<Goal<Self>, E>>
) -> Result<Self::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 goal_data<'a>(&self, goal: &'a Arc<GoalData<Self>>) -> &'a GoalData<Self>

Lookup the GoalData that was interned to create a InternedGoal.

fn goals_data<'a>(&self, goals: &'a Vec<Goal<Interner>>) -> &'a [Goal<Interner>]

Lookup the GoalsData that was interned to create a InternedGoals.

fn intern_substitution<E>(
    &self,
    data: impl IntoIterator<Item = Result<GenericArg<Self>, E>>
) -> Result<Self::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<'a>(
    &self,
    substitution: &'a Self::InternedSubstitution
) -> &'a [GenericArg<Self>]

Lookup the SubstitutionData that was interned to create a InternedSubstitution.

fn intern_program_clause(
    &self,
    data: ProgramClauseData<Self>
) -> Arc<ProgramClauseData<Self>>

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<'a>(
    &self,
    clause: &'a Arc<ProgramClauseData<Self>>
) -> &'a ProgramClauseData<Self>

Lookup the ProgramClauseData that was interned to create a ProgramClause.

fn intern_program_clauses<E>(
    &self,
    data: impl IntoIterator<Item = Result<ProgramClause<Self>, E>>
) -> Result<Arc<[ProgramClause<Self>]>, 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<'a>(
    &self,
    clauses: &'a Arc<[ProgramClause<Self>]>
) -> &'a [ProgramClause<Self>]

Lookup the ProgramClauseData that was interned to create a ProgramClause.

fn intern_quantified_where_clauses<E>(
    &self,
    data: impl IntoIterator<Item = Result<QuantifiedWhereClause<Self>, E>>
) -> Result<Self::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<'a>(
    &self,
    clauses: &'a Self::InternedQuantifiedWhereClauses
) -> &'a [QuantifiedWhereClause<Self>]

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<Self>, E>>
) -> Result<Self::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<'a>(
    &self,
    parameter_kinds: &'a Self::InternedVariableKinds
) -> &'a [VariableKind<Self>]

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

fn intern_canonical_var_kinds<E>(
    &self,
    data: impl IntoIterator<Item = Result<CanonicalVarKind<Self>, E>>
) -> Result<Self::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<'a>(
    &self,
    canonical_var_kinds: &'a Self::InternedCanonicalVarKinds
) -> &'a [CanonicalVarKind<Self>]

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

fn intern_constraints<E>(
    &self,
    data: impl IntoIterator<Item = Result<InEnvironment<Constraint<Self>>, E>>
) -> Result<Self::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<'a>(
    &self,
    constraints: &'a Self::InternedConstraints
) -> &'a [InEnvironment<Constraint<Self>>]

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

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

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

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

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

fn intern_variances<E>(
    &self,
    data: impl IntoIterator<Item = Result<Variance, E>>
) -> Result<Self::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<'a>(
    &self,
    variances: &'a Self::InternedVariances
) -> &'a [Variance]

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

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

pub fn debug_generator_id(
    generator_id: GeneratorId<Self>,
    fmt: &mut Formatter<'_>
) -> Option<Result<(), Error>>

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

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

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl PartialEq<Interner> for Interner

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialOrd<Interner> for Interner

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

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

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

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

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

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

impl StructuralEq for Interner

impl StructuralPartialEq for Interner