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.

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

Performs copy-assignment from source.

impl Debug for Interner

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

Formats the value using the given formatter.

impl Fold<Interner> for CallableSig

type Result = CallableSig

The type of value that will be produced once folding is done. Typically this is Self, unless Self contains borrowed values, in which case owned values are produced (for example, one can fold over a &T value where T: Fold, in which case you get back a T, not a &T).

fn fold_with<'i>(
    self,
    folder: &mut dyn Folder<'i, Interner>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    Interner: 'i, 

Apply the given folder folder to self; binders is the number of binders that are in scope when beginning the folder. Typically binders starts as 0, but is adjusted when we encounter Binders<T> in the IR or other similar constructs.

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.

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 = 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<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 = Interned<InternedWrapper<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 = 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<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 = Interned<InternedWrapper<SmallVec<[GenericArg; 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 = 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 = Interned<InternedWrapper<Vec<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 = Interned<InternedWrapper<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 = 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<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 = Interned<InternedWrapper<Vec<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,
    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>) -> Self::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<'a>(&self, ty: &'a Self::InternedType) -> &'a TyData<Self>

Lookup the TyKind from an interned type.

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

Lookup the LifetimeData that was interned to create a InternedLifetime.

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

Lookup the ConstData that was interned to create a InternedConst.

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

Determine whether two concrete const values are equal.

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

Lookup the LifetimeData that was interned to create a InternedLifetime.

fn intern_goal(&self, goal: GoalData<Self>) -> Self::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 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 Self::InternedGoal) -> &'a GoalData<Self>

Lookup the GoalData that was interned to create a InternedGoal.

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

Lookup the GoalsData that was interned to create a InternedGoals.

fn intern_substitution<E>(
    &self,
    data: impl IntoIterator<Item = Result<GenericArg, 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]

Lookup the SubstitutionData that was interned to create a InternedSubstitution.

fn intern_program_clause(
    &self,
    data: ProgramClauseData<Self>
) -> Self::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<'a>(
    &self,
    clause: &'a Self::InternedProgramClause
) -> &'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<Self::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<'a>(
    &self,
    clauses: &'a Self::InternedProgramClauses
) -> &'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.

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

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

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

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.

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

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

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

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

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

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

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<'a> UnificationDatabase<Interner> for &'a 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 StructuralEq for Interner

impl StructuralPartialEq for Interner