Struct rustc_middle::traits::ChalkRustInterner

pub struct ChalkRustInterner<'tcx> {
    pub tcx: TyCtxt<'tcx>,
}

Fields

tcx: TyCtxt<'tcx>

Trait Implementations

impl<'tcx> Clone for RustInterner<'tcx>

fn clone(&self) -> RustInterner<'tcx>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RustInterner<'_>

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

Formats the value using the given formatter.

impl<'tcx> HasInterner for RustInterner<'tcx>

type Interner = Self

The interner associated with the type.

impl<'tcx> Hash for RustInterner<'tcx>

We don’t ever actually need this. It’s only required for derives.

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<'tcx> Interner for RustInterner<'tcx>

type InternedType = Box<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 = Box<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 = Box<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 = ConstValue<'tcx>

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

type InternedGenericArg = Box<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 = Box<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 = Vec<GenericArg<Self>>

“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 = Box<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 = 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 = 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 InternedVariances = 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 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 DefId = DefId

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

type InternedAdtId = &'tcx AdtDef

The ID type for ADTs

type Identifier = ()

Representation of identifiers.

type FnAbi = Abi

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

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

Prints the debug representation of a SeparatorTraitRef. 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 debug_ty(ty: &Ty<Self>, fmt: &mut Formatter<'_>) -> Option<Result>

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

fn debug_alias(
    alias_ty: &AliasTy<Self>,
    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(
    projection_ty: &ProjectionTy<Self>,
    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<Self>,
    fmt: &mut Formatter<'_>
) -> Option<Result>

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

fn intern_ty(&self, ty: TyData<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

Deterermine whether two concrete const values are equal.

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

Lookup the GoalData that was interned to create a InternedGoal.

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 goals_data<'a>(&self, goals: &'a Self::InternedGoals) -> &'a [Goal<Self>]

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>
) -> 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 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_adt_id(
    adt_id: AdtId<Self>,
    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(
    trait_id: TraitId<Self>,
    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(
    type_id: AssocTypeId<Self>,
    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<Self>,
    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<Self>,
    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<Self>,
    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_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_lifetime(
    lifetime: &Lifetime<Self>,
    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<Self>,
    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(
    generic_arg: &GenericArg<Self>,
    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<Self>,
    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<Self>,
    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<Self>,
    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<Self>,
    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<Self>,
    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(
    clause: &ProgramClause<Self>,
    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<Self>,
    fmt: &mut Formatter<'_>
) -> Option<Result<(), Error>>

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

fn debug_constraints(
    clauses: &Constraints<Self>,
    fmt: &mut Formatter<'_>
) -> Option<Result<(), Error>>

Prints the debug representation of a Constraints. 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<'tcx> Ord for RustInterner<'tcx>

We don’t ever actually need this. It’s only required for derives.

fn cmp(&self, _other: &Self) -> Ordering

This method returns an Ordering between self and other.

#[must_use]

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

Compares and returns the maximum of two values.

#[must_use]

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

Compares and returns the minimum of two values.

#[must_use]

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

Restrict a value to a certain interval.

impl<'tcx> PartialEq<RustInterner<'tcx>> for RustInterner<'tcx>

We don’t ever actually need this. It’s only required for derives.

fn eq(&self, _other: &Self) -> bool

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

#[must_use]

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

This method tests for !=.

impl<'tcx> PartialOrd<RustInterner<'tcx>> for RustInterner<'tcx>

We don’t ever actually need this. It’s only required for derives.

fn partial_cmp(&self, _other: &Self) -> Option<Ordering>

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

#[must_use]

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

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

#[must_use]

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]

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

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

#[must_use]

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<'tcx> Copy for RustInterner<'tcx>

impl<'tcx> Eq for RustInterner<'tcx>

We don’t ever actually need this. It’s only required for derives.