1 //! Types required for Chalk-related queries
3 //! The primary purpose of this file is defining an implementation for the
4 //! `chalk_ir::interner::Interner` trait. The primary purpose of this trait, as
5 //! its name suggest, is to provide an abstraction boundary for creating
6 //! interned Chalk types.
8 use rustc_middle::mir::interpret::ConstValue;
9 use rustc_middle::ty::{self, AdtDef, TyCtxt};
11 use rustc_hir::def_id::DefId;
12 use rustc_target::spec::abi::Abi;
14 use std::cmp::Ordering;
16 use std::hash::{Hash, Hasher};
18 #[derive(Copy, Clone)]
19 pub struct RustInterner<'tcx> {
20 pub tcx: TyCtxt<'tcx>,
23 /// We don't ever actually need this. It's only required for derives.
24 impl<'tcx> Hash for RustInterner<'tcx> {
25 fn hash<H: Hasher>(&self, _state: &mut H) {}
28 /// We don't ever actually need this. It's only required for derives.
29 impl<'tcx> Ord for RustInterner<'tcx> {
30 fn cmp(&self, _other: &Self) -> Ordering {
35 /// We don't ever actually need this. It's only required for derives.
36 impl<'tcx> PartialOrd for RustInterner<'tcx> {
37 fn partial_cmp(&self, _other: &Self) -> Option<Ordering> {
42 /// We don't ever actually need this. It's only required for derives.
43 impl<'tcx> PartialEq for RustInterner<'tcx> {
44 fn eq(&self, _other: &Self) -> bool {
49 /// We don't ever actually need this. It's only required for derives.
50 impl<'tcx> Eq for RustInterner<'tcx> {}
52 impl fmt::Debug for RustInterner<'_> {
53 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
54 write!(f, "RustInterner")
58 // Right now, there is no interning at all. I was running into problems with
59 // adding interning in `ty/context.rs` for Chalk types with
60 // `parallel-compiler = true`. -jackh726
61 impl<'tcx> chalk_ir::interner::Interner for RustInterner<'tcx> {
62 type InternedType = Box<chalk_ir::TyData<Self>>;
63 type InternedLifetime = Box<chalk_ir::LifetimeData<Self>>;
64 type InternedConst = Box<chalk_ir::ConstData<Self>>;
65 type InternedConcreteConst = ConstValue<'tcx>;
66 type InternedGenericArg = Box<chalk_ir::GenericArgData<Self>>;
67 type InternedGoal = Box<chalk_ir::GoalData<Self>>;
68 type InternedGoals = Vec<chalk_ir::Goal<Self>>;
69 type InternedSubstitution = Vec<chalk_ir::GenericArg<Self>>;
70 type InternedProgramClause = Box<chalk_ir::ProgramClauseData<Self>>;
71 type InternedProgramClauses = Vec<chalk_ir::ProgramClause<Self>>;
72 type InternedQuantifiedWhereClauses = Vec<chalk_ir::QuantifiedWhereClause<Self>>;
73 type InternedVariableKinds = Vec<chalk_ir::VariableKind<Self>>;
74 type InternedCanonicalVarKinds = Vec<chalk_ir::CanonicalVarKind<Self>>;
75 type InternedVariances = Vec<chalk_ir::Variance>;
76 type InternedConstraints = Vec<chalk_ir::InEnvironment<chalk_ir::Constraint<Self>>>;
78 type InternedAdtId = &'tcx AdtDef;
82 fn debug_program_clause_implication(
83 pci: &chalk_ir::ProgramClauseImplication<Self>,
84 fmt: &mut fmt::Formatter<'_>,
85 ) -> Option<fmt::Result> {
87 write!(fmt, "{:?}", pci.consequence)?;
89 let conditions = pci.conditions.interned();
90 let constraints = pci.constraints.interned();
92 let conds = conditions.len();
93 let consts = constraints.len();
94 if conds == 0 && consts == 0 {
101 for cond in &conditions[..conds - 1] {
102 write!(fmt, "{:?}, ", cond)?;
104 write!(fmt, "{:?}", conditions[conds - 1])?;
107 if conds != 0 && consts != 0 {
112 for constraint in &constraints[..consts - 1] {
113 write!(fmt, "{:?}, ", constraint)?;
115 write!(fmt, "{:?}", constraints[consts - 1])?;
123 fn debug_substitution(
124 substitution: &chalk_ir::Substitution<Self>,
125 fmt: &mut fmt::Formatter<'_>,
126 ) -> Option<fmt::Result> {
127 Some(write!(fmt, "{:?}", substitution.interned()))
130 fn debug_separator_trait_ref(
131 separator_trait_ref: &chalk_ir::SeparatorTraitRef<'_, Self>,
132 fmt: &mut fmt::Formatter<'_>,
133 ) -> Option<fmt::Result> {
134 let substitution = &separator_trait_ref.trait_ref.substitution;
135 let parameters = substitution.interned();
140 separator_trait_ref.separator,
141 separator_trait_ref.trait_ref.trait_id,
142 chalk_ir::debug::Angle(¶meters[1..])
146 fn debug_quantified_where_clauses(
147 clauses: &chalk_ir::QuantifiedWhereClauses<Self>,
148 fmt: &mut fmt::Formatter<'_>,
149 ) -> Option<fmt::Result> {
150 Some(write!(fmt, "{:?}", clauses.interned()))
153 fn debug_ty(ty: &chalk_ir::Ty<Self>, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
154 match &ty.interned().kind {
155 chalk_ir::TyKind::Ref(chalk_ir::Mutability::Not, lifetime, ty) => {
156 Some(write!(fmt, "(&{:?} {:?})", lifetime, ty))
158 chalk_ir::TyKind::Ref(chalk_ir::Mutability::Mut, lifetime, ty) => {
159 Some(write!(fmt, "(&{:?} mut {:?})", lifetime, ty))
161 chalk_ir::TyKind::Array(ty, len) => Some(write!(fmt, "[{:?}; {:?}]", ty, len)),
162 chalk_ir::TyKind::Slice(ty) => Some(write!(fmt, "[{:?}]", ty)),
163 chalk_ir::TyKind::Tuple(len, substs) => Some((|| {
165 for (idx, substitution) in substs.interned().iter().enumerate() {
166 if idx == *len && *len != 1 {
167 // Don't add a trailing comma if the tuple has more than one element
168 write!(fmt, "{:?}", substitution)?;
170 write!(fmt, "{:?},", substitution)?;
180 alias_ty: &chalk_ir::AliasTy<Self>,
181 fmt: &mut fmt::Formatter<'_>,
182 ) -> Option<fmt::Result> {
184 chalk_ir::AliasTy::Projection(projection_ty) => {
185 Self::debug_projection_ty(projection_ty, fmt)
187 chalk_ir::AliasTy::Opaque(opaque_ty) => Self::debug_opaque_ty(opaque_ty, fmt),
191 fn debug_projection_ty(
192 projection_ty: &chalk_ir::ProjectionTy<Self>,
193 fmt: &mut fmt::Formatter<'_>,
194 ) -> Option<fmt::Result> {
197 "projection: {:?} {:?}",
198 projection_ty.associated_ty_id, projection_ty.substitution,
203 opaque_ty: &chalk_ir::OpaqueTy<Self>,
204 fmt: &mut fmt::Formatter<'_>,
205 ) -> Option<fmt::Result> {
206 Some(write!(fmt, "{:?}", opaque_ty.opaque_ty_id))
209 fn intern_ty(&self, ty: chalk_ir::TyData<Self>) -> Self::InternedType {
213 fn ty_data<'a>(&self, ty: &'a Self::InternedType) -> &'a chalk_ir::TyData<Self> {
217 fn intern_lifetime(&self, lifetime: chalk_ir::LifetimeData<Self>) -> Self::InternedLifetime {
221 fn lifetime_data<'a>(
223 lifetime: &'a Self::InternedLifetime,
224 ) -> &'a chalk_ir::LifetimeData<Self> {
228 fn intern_const(&self, constant: chalk_ir::ConstData<Self>) -> Self::InternedConst {
232 fn const_data<'a>(&self, constant: &'a Self::InternedConst) -> &'a chalk_ir::ConstData<Self> {
238 _ty: &Self::InternedType,
239 c1: &Self::InternedConcreteConst,
240 c2: &Self::InternedConcreteConst,
245 fn intern_generic_arg(&self, data: chalk_ir::GenericArgData<Self>) -> Self::InternedGenericArg {
249 fn generic_arg_data<'a>(
251 data: &'a Self::InternedGenericArg,
252 ) -> &'a chalk_ir::GenericArgData<Self> {
256 fn intern_goal(&self, goal: chalk_ir::GoalData<Self>) -> Self::InternedGoal {
260 fn goal_data<'a>(&self, goal: &'a Self::InternedGoal) -> &'a chalk_ir::GoalData<Self> {
266 data: impl IntoIterator<Item = Result<chalk_ir::Goal<Self>, E>>,
267 ) -> Result<Self::InternedGoals, E> {
268 data.into_iter().collect::<Result<Vec<_>, _>>()
271 fn goals_data<'a>(&self, goals: &'a Self::InternedGoals) -> &'a [chalk_ir::Goal<Self>] {
275 fn intern_substitution<E>(
277 data: impl IntoIterator<Item = Result<chalk_ir::GenericArg<Self>, E>>,
278 ) -> Result<Self::InternedSubstitution, E> {
279 data.into_iter().collect::<Result<Vec<_>, _>>()
282 fn substitution_data<'a>(
284 substitution: &'a Self::InternedSubstitution,
285 ) -> &'a [chalk_ir::GenericArg<Self>] {
289 fn intern_program_clause(
291 data: chalk_ir::ProgramClauseData<Self>,
292 ) -> Self::InternedProgramClause {
296 fn program_clause_data<'a>(
298 clause: &'a Self::InternedProgramClause,
299 ) -> &'a chalk_ir::ProgramClauseData<Self> {
303 fn intern_program_clauses<E>(
305 data: impl IntoIterator<Item = Result<chalk_ir::ProgramClause<Self>, E>>,
306 ) -> Result<Self::InternedProgramClauses, E> {
307 data.into_iter().collect::<Result<Vec<_>, _>>()
310 fn program_clauses_data<'a>(
312 clauses: &'a Self::InternedProgramClauses,
313 ) -> &'a [chalk_ir::ProgramClause<Self>] {
317 fn intern_quantified_where_clauses<E>(
319 data: impl IntoIterator<Item = Result<chalk_ir::QuantifiedWhereClause<Self>, E>>,
320 ) -> Result<Self::InternedQuantifiedWhereClauses, E> {
321 data.into_iter().collect::<Result<Vec<_>, _>>()
324 fn quantified_where_clauses_data<'a>(
326 clauses: &'a Self::InternedQuantifiedWhereClauses,
327 ) -> &'a [chalk_ir::QuantifiedWhereClause<Self>] {
331 fn intern_generic_arg_kinds<E>(
333 data: impl IntoIterator<Item = Result<chalk_ir::VariableKind<Self>, E>>,
334 ) -> Result<Self::InternedVariableKinds, E> {
335 data.into_iter().collect::<Result<Vec<_>, _>>()
338 fn variable_kinds_data<'a>(
340 parameter_kinds: &'a Self::InternedVariableKinds,
341 ) -> &'a [chalk_ir::VariableKind<Self>] {
345 fn intern_canonical_var_kinds<E>(
347 data: impl IntoIterator<Item = Result<chalk_ir::CanonicalVarKind<Self>, E>>,
348 ) -> Result<Self::InternedCanonicalVarKinds, E> {
349 data.into_iter().collect::<Result<Vec<_>, _>>()
352 fn canonical_var_kinds_data<'a>(
354 canonical_var_kinds: &'a Self::InternedCanonicalVarKinds,
355 ) -> &'a [chalk_ir::CanonicalVarKind<Self>] {
359 fn intern_constraints<E>(
361 data: impl IntoIterator<Item = Result<chalk_ir::InEnvironment<chalk_ir::Constraint<Self>>, E>>,
362 ) -> Result<Self::InternedConstraints, E> {
363 data.into_iter().collect::<Result<Vec<_>, _>>()
366 fn constraints_data<'a>(
368 constraints: &'a Self::InternedConstraints,
369 ) -> &'a [chalk_ir::InEnvironment<chalk_ir::Constraint<Self>>] {
373 fn intern_variances<E>(
375 data: impl IntoIterator<Item = Result<chalk_ir::Variance, E>>,
376 ) -> Result<Self::InternedVariances, E> {
377 data.into_iter().collect::<Result<Vec<_>, _>>()
380 fn variances_data<'a>(
382 variances: &'a Self::InternedVariances,
383 ) -> &'a [chalk_ir::Variance] {
388 impl<'tcx> chalk_ir::interner::HasInterner for RustInterner<'tcx> {
389 type Interner = Self;
392 /// A chalk environment and goal.
393 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, HashStable, TypeFoldable)]
394 pub struct ChalkEnvironmentAndGoal<'tcx> {
395 pub environment: &'tcx ty::List<ty::Predicate<'tcx>>,
396 pub goal: ty::Predicate<'tcx>,
399 impl<'tcx> fmt::Display for ChalkEnvironmentAndGoal<'tcx> {
400 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
401 write!(f, "environment: {:?}, goal: {}", self.environment, self.goal)