diff options
Diffstat (limited to 'crates/hir_ty/src/traits/chalk')
-rw-r--r-- | crates/hir_ty/src/traits/chalk/interner.rs | 421 | ||||
-rw-r--r-- | crates/hir_ty/src/traits/chalk/mapping.rs | 131 | ||||
-rw-r--r-- | crates/hir_ty/src/traits/chalk/tls.rs | 275 |
3 files changed, 0 insertions, 827 deletions
diff --git a/crates/hir_ty/src/traits/chalk/interner.rs b/crates/hir_ty/src/traits/chalk/interner.rs deleted file mode 100644 index b6a3cec6d..000000000 --- a/crates/hir_ty/src/traits/chalk/interner.rs +++ /dev/null | |||
@@ -1,421 +0,0 @@ | |||
1 | //! Implementation of the Chalk `Interner` trait, which allows customizing the | ||
2 | //! representation of the various objects Chalk deals with (types, goals etc.). | ||
3 | |||
4 | use super::tls; | ||
5 | use crate::GenericArg; | ||
6 | use base_db::salsa::InternId; | ||
7 | use chalk_ir::{Goal, GoalData}; | ||
8 | use hir_def::{ | ||
9 | intern::{impl_internable, InternStorage, Internable, Interned}, | ||
10 | TypeAliasId, | ||
11 | }; | ||
12 | use smallvec::SmallVec; | ||
13 | use std::{fmt, sync::Arc}; | ||
14 | |||
15 | #[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)] | ||
16 | pub struct Interner; | ||
17 | |||
18 | pub(crate) type AssocTypeId = chalk_ir::AssocTypeId<Interner>; | ||
19 | pub(crate) type AssociatedTyDatum = chalk_solve::rust_ir::AssociatedTyDatum<Interner>; | ||
20 | pub(crate) type TraitId = chalk_ir::TraitId<Interner>; | ||
21 | pub(crate) type TraitDatum = chalk_solve::rust_ir::TraitDatum<Interner>; | ||
22 | pub(crate) type AdtId = chalk_ir::AdtId<Interner>; | ||
23 | pub(crate) type StructDatum = chalk_solve::rust_ir::AdtDatum<Interner>; | ||
24 | pub(crate) type ImplId = chalk_ir::ImplId<Interner>; | ||
25 | pub(crate) type ImplDatum = chalk_solve::rust_ir::ImplDatum<Interner>; | ||
26 | pub(crate) type AssociatedTyValueId = chalk_solve::rust_ir::AssociatedTyValueId<Interner>; | ||
27 | pub(crate) type AssociatedTyValue = chalk_solve::rust_ir::AssociatedTyValue<Interner>; | ||
28 | pub(crate) type FnDefDatum = chalk_solve::rust_ir::FnDefDatum<Interner>; | ||
29 | pub(crate) type OpaqueTyId = chalk_ir::OpaqueTyId<Interner>; | ||
30 | pub(crate) type OpaqueTyDatum = chalk_solve::rust_ir::OpaqueTyDatum<Interner>; | ||
31 | pub(crate) type Variances = chalk_ir::Variances<Interner>; | ||
32 | |||
33 | #[derive(PartialEq, Eq, Hash, Debug)] | ||
34 | pub struct InternedWrapper<T>(T); | ||
35 | |||
36 | impl<T> std::ops::Deref for InternedWrapper<T> { | ||
37 | type Target = T; | ||
38 | |||
39 | fn deref(&self) -> &Self::Target { | ||
40 | &self.0 | ||
41 | } | ||
42 | } | ||
43 | |||
44 | impl_internable!( | ||
45 | InternedWrapper<Vec<chalk_ir::VariableKind<Interner>>>, | ||
46 | InternedWrapper<SmallVec<[GenericArg; 2]>>, | ||
47 | InternedWrapper<chalk_ir::TyData<Interner>>, | ||
48 | InternedWrapper<chalk_ir::LifetimeData<Interner>>, | ||
49 | InternedWrapper<chalk_ir::ConstData<Interner>>, | ||
50 | InternedWrapper<Vec<chalk_ir::CanonicalVarKind<Interner>>>, | ||
51 | InternedWrapper<Vec<chalk_ir::ProgramClause<Interner>>>, | ||
52 | InternedWrapper<Vec<chalk_ir::QuantifiedWhereClause<Interner>>>, | ||
53 | InternedWrapper<Vec<chalk_ir::Variance>>, | ||
54 | ); | ||
55 | |||
56 | impl chalk_ir::interner::Interner for Interner { | ||
57 | type InternedType = Interned<InternedWrapper<chalk_ir::TyData<Interner>>>; | ||
58 | type InternedLifetime = Interned<InternedWrapper<chalk_ir::LifetimeData<Self>>>; | ||
59 | type InternedConst = Interned<InternedWrapper<chalk_ir::ConstData<Self>>>; | ||
60 | type InternedConcreteConst = (); | ||
61 | type InternedGenericArg = chalk_ir::GenericArgData<Self>; | ||
62 | type InternedGoal = Arc<GoalData<Self>>; | ||
63 | type InternedGoals = Vec<Goal<Self>>; | ||
64 | type InternedSubstitution = Interned<InternedWrapper<SmallVec<[GenericArg; 2]>>>; | ||
65 | type InternedProgramClause = chalk_ir::ProgramClauseData<Self>; | ||
66 | type InternedProgramClauses = Interned<InternedWrapper<Vec<chalk_ir::ProgramClause<Self>>>>; | ||
67 | type InternedQuantifiedWhereClauses = | ||
68 | Interned<InternedWrapper<Vec<chalk_ir::QuantifiedWhereClause<Self>>>>; | ||
69 | type InternedVariableKinds = Interned<InternedWrapper<Vec<chalk_ir::VariableKind<Interner>>>>; | ||
70 | type InternedCanonicalVarKinds = | ||
71 | Interned<InternedWrapper<Vec<chalk_ir::CanonicalVarKind<Self>>>>; | ||
72 | type InternedConstraints = Vec<chalk_ir::InEnvironment<chalk_ir::Constraint<Self>>>; | ||
73 | type InternedVariances = Interned<InternedWrapper<Vec<chalk_ir::Variance>>>; | ||
74 | type DefId = InternId; | ||
75 | type InternedAdtId = hir_def::AdtId; | ||
76 | type Identifier = TypeAliasId; | ||
77 | type FnAbi = (); | ||
78 | |||
79 | fn debug_adt_id(type_kind_id: AdtId, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> { | ||
80 | tls::with_current_program(|prog| Some(prog?.debug_struct_id(type_kind_id, fmt))) | ||
81 | } | ||
82 | |||
83 | fn debug_trait_id(type_kind_id: TraitId, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> { | ||
84 | tls::with_current_program(|prog| Some(prog?.debug_trait_id(type_kind_id, fmt))) | ||
85 | } | ||
86 | |||
87 | fn debug_assoc_type_id(id: AssocTypeId, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> { | ||
88 | tls::with_current_program(|prog| Some(prog?.debug_assoc_type_id(id, fmt))) | ||
89 | } | ||
90 | |||
91 | fn debug_alias( | ||
92 | alias: &chalk_ir::AliasTy<Interner>, | ||
93 | fmt: &mut fmt::Formatter<'_>, | ||
94 | ) -> Option<fmt::Result> { | ||
95 | tls::with_current_program(|prog| Some(prog?.debug_alias(alias, fmt))) | ||
96 | } | ||
97 | |||
98 | fn debug_projection_ty( | ||
99 | proj: &chalk_ir::ProjectionTy<Interner>, | ||
100 | fmt: &mut fmt::Formatter<'_>, | ||
101 | ) -> Option<fmt::Result> { | ||
102 | tls::with_current_program(|prog| Some(prog?.debug_projection_ty(proj, fmt))) | ||
103 | } | ||
104 | |||
105 | fn debug_opaque_ty( | ||
106 | opaque_ty: &chalk_ir::OpaqueTy<Interner>, | ||
107 | fmt: &mut fmt::Formatter<'_>, | ||
108 | ) -> Option<fmt::Result> { | ||
109 | tls::with_current_program(|prog| Some(prog?.debug_opaque_ty(opaque_ty, fmt))) | ||
110 | } | ||
111 | |||
112 | fn debug_opaque_ty_id( | ||
113 | opaque_ty_id: chalk_ir::OpaqueTyId<Self>, | ||
114 | fmt: &mut fmt::Formatter<'_>, | ||
115 | ) -> Option<fmt::Result> { | ||
116 | tls::with_current_program(|prog| Some(prog?.debug_opaque_ty_id(opaque_ty_id, fmt))) | ||
117 | } | ||
118 | |||
119 | fn debug_ty(ty: &chalk_ir::Ty<Interner>, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> { | ||
120 | tls::with_current_program(|prog| Some(prog?.debug_ty(ty, fmt))) | ||
121 | } | ||
122 | |||
123 | fn debug_lifetime( | ||
124 | lifetime: &chalk_ir::Lifetime<Interner>, | ||
125 | fmt: &mut fmt::Formatter<'_>, | ||
126 | ) -> Option<fmt::Result> { | ||
127 | tls::with_current_program(|prog| Some(prog?.debug_lifetime(lifetime, fmt))) | ||
128 | } | ||
129 | |||
130 | fn debug_generic_arg( | ||
131 | parameter: &GenericArg, | ||
132 | fmt: &mut fmt::Formatter<'_>, | ||
133 | ) -> Option<fmt::Result> { | ||
134 | tls::with_current_program(|prog| Some(prog?.debug_generic_arg(parameter, fmt))) | ||
135 | } | ||
136 | |||
137 | fn debug_goal(goal: &Goal<Interner>, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> { | ||
138 | tls::with_current_program(|prog| Some(prog?.debug_goal(goal, fmt))) | ||
139 | } | ||
140 | |||
141 | fn debug_goals( | ||
142 | goals: &chalk_ir::Goals<Interner>, | ||
143 | fmt: &mut fmt::Formatter<'_>, | ||
144 | ) -> Option<fmt::Result> { | ||
145 | tls::with_current_program(|prog| Some(prog?.debug_goals(goals, fmt))) | ||
146 | } | ||
147 | |||
148 | fn debug_program_clause_implication( | ||
149 | pci: &chalk_ir::ProgramClauseImplication<Interner>, | ||
150 | fmt: &mut fmt::Formatter<'_>, | ||
151 | ) -> Option<fmt::Result> { | ||
152 | tls::with_current_program(|prog| Some(prog?.debug_program_clause_implication(pci, fmt))) | ||
153 | } | ||
154 | |||
155 | fn debug_substitution( | ||
156 | substitution: &chalk_ir::Substitution<Interner>, | ||
157 | fmt: &mut fmt::Formatter<'_>, | ||
158 | ) -> Option<fmt::Result> { | ||
159 | tls::with_current_program(|prog| Some(prog?.debug_substitution(substitution, fmt))) | ||
160 | } | ||
161 | |||
162 | fn debug_separator_trait_ref( | ||
163 | separator_trait_ref: &chalk_ir::SeparatorTraitRef<Interner>, | ||
164 | fmt: &mut fmt::Formatter<'_>, | ||
165 | ) -> Option<fmt::Result> { | ||
166 | tls::with_current_program(|prog| { | ||
167 | Some(prog?.debug_separator_trait_ref(separator_trait_ref, fmt)) | ||
168 | }) | ||
169 | } | ||
170 | |||
171 | fn debug_fn_def_id( | ||
172 | fn_def_id: chalk_ir::FnDefId<Self>, | ||
173 | fmt: &mut fmt::Formatter<'_>, | ||
174 | ) -> Option<fmt::Result> { | ||
175 | tls::with_current_program(|prog| Some(prog?.debug_fn_def_id(fn_def_id, fmt))) | ||
176 | } | ||
177 | fn debug_const( | ||
178 | constant: &chalk_ir::Const<Self>, | ||
179 | fmt: &mut fmt::Formatter<'_>, | ||
180 | ) -> Option<fmt::Result> { | ||
181 | tls::with_current_program(|prog| Some(prog?.debug_const(constant, fmt))) | ||
182 | } | ||
183 | fn debug_variable_kinds( | ||
184 | variable_kinds: &chalk_ir::VariableKinds<Self>, | ||
185 | fmt: &mut fmt::Formatter<'_>, | ||
186 | ) -> Option<fmt::Result> { | ||
187 | tls::with_current_program(|prog| Some(prog?.debug_variable_kinds(variable_kinds, fmt))) | ||
188 | } | ||
189 | fn debug_variable_kinds_with_angles( | ||
190 | variable_kinds: &chalk_ir::VariableKinds<Self>, | ||
191 | fmt: &mut fmt::Formatter<'_>, | ||
192 | ) -> Option<fmt::Result> { | ||
193 | tls::with_current_program(|prog| { | ||
194 | Some(prog?.debug_variable_kinds_with_angles(variable_kinds, fmt)) | ||
195 | }) | ||
196 | } | ||
197 | fn debug_canonical_var_kinds( | ||
198 | canonical_var_kinds: &chalk_ir::CanonicalVarKinds<Self>, | ||
199 | fmt: &mut fmt::Formatter<'_>, | ||
200 | ) -> Option<fmt::Result> { | ||
201 | tls::with_current_program(|prog| { | ||
202 | Some(prog?.debug_canonical_var_kinds(canonical_var_kinds, fmt)) | ||
203 | }) | ||
204 | } | ||
205 | fn debug_program_clause( | ||
206 | clause: &chalk_ir::ProgramClause<Self>, | ||
207 | fmt: &mut fmt::Formatter<'_>, | ||
208 | ) -> Option<fmt::Result> { | ||
209 | tls::with_current_program(|prog| Some(prog?.debug_program_clause(clause, fmt))) | ||
210 | } | ||
211 | fn debug_program_clauses( | ||
212 | clauses: &chalk_ir::ProgramClauses<Self>, | ||
213 | fmt: &mut fmt::Formatter<'_>, | ||
214 | ) -> Option<fmt::Result> { | ||
215 | tls::with_current_program(|prog| Some(prog?.debug_program_clauses(clauses, fmt))) | ||
216 | } | ||
217 | fn debug_quantified_where_clauses( | ||
218 | clauses: &chalk_ir::QuantifiedWhereClauses<Self>, | ||
219 | fmt: &mut fmt::Formatter<'_>, | ||
220 | ) -> Option<fmt::Result> { | ||
221 | tls::with_current_program(|prog| Some(prog?.debug_quantified_where_clauses(clauses, fmt))) | ||
222 | } | ||
223 | |||
224 | fn intern_ty(&self, kind: chalk_ir::TyKind<Self>) -> Self::InternedType { | ||
225 | let flags = kind.compute_flags(self); | ||
226 | Interned::new(InternedWrapper(chalk_ir::TyData { kind, flags })) | ||
227 | } | ||
228 | |||
229 | fn ty_data<'a>(&self, ty: &'a Self::InternedType) -> &'a chalk_ir::TyData<Self> { | ||
230 | &ty.0 | ||
231 | } | ||
232 | |||
233 | fn intern_lifetime(&self, lifetime: chalk_ir::LifetimeData<Self>) -> Self::InternedLifetime { | ||
234 | Interned::new(InternedWrapper(lifetime)) | ||
235 | } | ||
236 | |||
237 | fn lifetime_data<'a>( | ||
238 | &self, | ||
239 | lifetime: &'a Self::InternedLifetime, | ||
240 | ) -> &'a chalk_ir::LifetimeData<Self> { | ||
241 | &lifetime.0 | ||
242 | } | ||
243 | |||
244 | fn intern_const(&self, constant: chalk_ir::ConstData<Self>) -> Self::InternedConst { | ||
245 | Interned::new(InternedWrapper(constant)) | ||
246 | } | ||
247 | |||
248 | fn const_data<'a>(&self, constant: &'a Self::InternedConst) -> &'a chalk_ir::ConstData<Self> { | ||
249 | &constant.0 | ||
250 | } | ||
251 | |||
252 | fn const_eq( | ||
253 | &self, | ||
254 | _ty: &Self::InternedType, | ||
255 | _c1: &Self::InternedConcreteConst, | ||
256 | _c2: &Self::InternedConcreteConst, | ||
257 | ) -> bool { | ||
258 | true | ||
259 | } | ||
260 | |||
261 | fn intern_generic_arg( | ||
262 | &self, | ||
263 | parameter: chalk_ir::GenericArgData<Self>, | ||
264 | ) -> Self::InternedGenericArg { | ||
265 | parameter | ||
266 | } | ||
267 | |||
268 | fn generic_arg_data<'a>( | ||
269 | &self, | ||
270 | parameter: &'a Self::InternedGenericArg, | ||
271 | ) -> &'a chalk_ir::GenericArgData<Self> { | ||
272 | parameter | ||
273 | } | ||
274 | |||
275 | fn intern_goal(&self, goal: GoalData<Self>) -> Self::InternedGoal { | ||
276 | Arc::new(goal) | ||
277 | } | ||
278 | |||
279 | fn intern_goals<E>( | ||
280 | &self, | ||
281 | data: impl IntoIterator<Item = Result<Goal<Self>, E>>, | ||
282 | ) -> Result<Self::InternedGoals, E> { | ||
283 | data.into_iter().collect() | ||
284 | } | ||
285 | |||
286 | fn goal_data<'a>(&self, goal: &'a Self::InternedGoal) -> &'a GoalData<Self> { | ||
287 | goal | ||
288 | } | ||
289 | |||
290 | fn goals_data<'a>(&self, goals: &'a Self::InternedGoals) -> &'a [Goal<Interner>] { | ||
291 | goals | ||
292 | } | ||
293 | |||
294 | fn intern_substitution<E>( | ||
295 | &self, | ||
296 | data: impl IntoIterator<Item = Result<GenericArg, E>>, | ||
297 | ) -> Result<Self::InternedSubstitution, E> { | ||
298 | Ok(Interned::new(InternedWrapper(data.into_iter().collect::<Result<_, _>>()?))) | ||
299 | } | ||
300 | |||
301 | fn substitution_data<'a>( | ||
302 | &self, | ||
303 | substitution: &'a Self::InternedSubstitution, | ||
304 | ) -> &'a [GenericArg] { | ||
305 | &substitution.as_ref().0 | ||
306 | } | ||
307 | |||
308 | fn intern_program_clause( | ||
309 | &self, | ||
310 | data: chalk_ir::ProgramClauseData<Self>, | ||
311 | ) -> Self::InternedProgramClause { | ||
312 | data | ||
313 | } | ||
314 | |||
315 | fn program_clause_data<'a>( | ||
316 | &self, | ||
317 | clause: &'a Self::InternedProgramClause, | ||
318 | ) -> &'a chalk_ir::ProgramClauseData<Self> { | ||
319 | clause | ||
320 | } | ||
321 | |||
322 | fn intern_program_clauses<E>( | ||
323 | &self, | ||
324 | data: impl IntoIterator<Item = Result<chalk_ir::ProgramClause<Self>, E>>, | ||
325 | ) -> Result<Self::InternedProgramClauses, E> { | ||
326 | Ok(Interned::new(InternedWrapper(data.into_iter().collect::<Result<_, _>>()?))) | ||
327 | } | ||
328 | |||
329 | fn program_clauses_data<'a>( | ||
330 | &self, | ||
331 | clauses: &'a Self::InternedProgramClauses, | ||
332 | ) -> &'a [chalk_ir::ProgramClause<Self>] { | ||
333 | &clauses | ||
334 | } | ||
335 | |||
336 | fn intern_quantified_where_clauses<E>( | ||
337 | &self, | ||
338 | data: impl IntoIterator<Item = Result<chalk_ir::QuantifiedWhereClause<Self>, E>>, | ||
339 | ) -> Result<Self::InternedQuantifiedWhereClauses, E> { | ||
340 | Ok(Interned::new(InternedWrapper(data.into_iter().collect::<Result<_, _>>()?))) | ||
341 | } | ||
342 | |||
343 | fn quantified_where_clauses_data<'a>( | ||
344 | &self, | ||
345 | clauses: &'a Self::InternedQuantifiedWhereClauses, | ||
346 | ) -> &'a [chalk_ir::QuantifiedWhereClause<Self>] { | ||
347 | clauses | ||
348 | } | ||
349 | |||
350 | fn intern_generic_arg_kinds<E>( | ||
351 | &self, | ||
352 | data: impl IntoIterator<Item = Result<chalk_ir::VariableKind<Self>, E>>, | ||
353 | ) -> Result<Self::InternedVariableKinds, E> { | ||
354 | Ok(Interned::new(InternedWrapper(data.into_iter().collect::<Result<_, _>>()?))) | ||
355 | } | ||
356 | |||
357 | fn variable_kinds_data<'a>( | ||
358 | &self, | ||
359 | parameter_kinds: &'a Self::InternedVariableKinds, | ||
360 | ) -> &'a [chalk_ir::VariableKind<Self>] { | ||
361 | ¶meter_kinds.as_ref().0 | ||
362 | } | ||
363 | |||
364 | fn intern_canonical_var_kinds<E>( | ||
365 | &self, | ||
366 | data: impl IntoIterator<Item = Result<chalk_ir::CanonicalVarKind<Self>, E>>, | ||
367 | ) -> Result<Self::InternedCanonicalVarKinds, E> { | ||
368 | Ok(Interned::new(InternedWrapper(data.into_iter().collect::<Result<_, _>>()?))) | ||
369 | } | ||
370 | |||
371 | fn canonical_var_kinds_data<'a>( | ||
372 | &self, | ||
373 | canonical_var_kinds: &'a Self::InternedCanonicalVarKinds, | ||
374 | ) -> &'a [chalk_ir::CanonicalVarKind<Self>] { | ||
375 | &canonical_var_kinds | ||
376 | } | ||
377 | |||
378 | fn intern_constraints<E>( | ||
379 | &self, | ||
380 | data: impl IntoIterator<Item = Result<chalk_ir::InEnvironment<chalk_ir::Constraint<Self>>, E>>, | ||
381 | ) -> Result<Self::InternedConstraints, E> { | ||
382 | data.into_iter().collect() | ||
383 | } | ||
384 | |||
385 | fn constraints_data<'a>( | ||
386 | &self, | ||
387 | constraints: &'a Self::InternedConstraints, | ||
388 | ) -> &'a [chalk_ir::InEnvironment<chalk_ir::Constraint<Self>>] { | ||
389 | constraints | ||
390 | } | ||
391 | fn debug_closure_id( | ||
392 | _fn_def_id: chalk_ir::ClosureId<Self>, | ||
393 | _fmt: &mut fmt::Formatter<'_>, | ||
394 | ) -> Option<fmt::Result> { | ||
395 | None | ||
396 | } | ||
397 | fn debug_constraints( | ||
398 | _clauses: &chalk_ir::Constraints<Self>, | ||
399 | _fmt: &mut fmt::Formatter<'_>, | ||
400 | ) -> Option<fmt::Result> { | ||
401 | None | ||
402 | } | ||
403 | |||
404 | fn intern_variances<E>( | ||
405 | &self, | ||
406 | data: impl IntoIterator<Item = Result<chalk_ir::Variance, E>>, | ||
407 | ) -> Result<Self::InternedVariances, E> { | ||
408 | Ok(Interned::new(InternedWrapper(data.into_iter().collect::<Result<_, _>>()?))) | ||
409 | } | ||
410 | |||
411 | fn variances_data<'a>( | ||
412 | &self, | ||
413 | variances: &'a Self::InternedVariances, | ||
414 | ) -> &'a [chalk_ir::Variance] { | ||
415 | &variances | ||
416 | } | ||
417 | } | ||
418 | |||
419 | impl chalk_ir::interner::HasInterner for Interner { | ||
420 | type Interner = Self; | ||
421 | } | ||
diff --git a/crates/hir_ty/src/traits/chalk/mapping.rs b/crates/hir_ty/src/traits/chalk/mapping.rs deleted file mode 100644 index e78581ea5..000000000 --- a/crates/hir_ty/src/traits/chalk/mapping.rs +++ /dev/null | |||
@@ -1,131 +0,0 @@ | |||
1 | //! This module contains the implementations of the `ToChalk` trait, which | ||
2 | //! handles conversion between our data types and their corresponding types in | ||
3 | //! Chalk (in both directions); plus some helper functions for more specialized | ||
4 | //! conversions. | ||
5 | |||
6 | use chalk_ir::cast::Cast; | ||
7 | use chalk_solve::rust_ir; | ||
8 | |||
9 | use base_db::salsa::InternKey; | ||
10 | use hir_def::{GenericDefId, TypeAliasId}; | ||
11 | |||
12 | use crate::{ | ||
13 | db::HirDatabase, AliasTy, CallableDefId, ProjectionTyExt, QuantifiedWhereClause, Substitution, | ||
14 | Ty, WhereClause, | ||
15 | }; | ||
16 | |||
17 | use super::interner::*; | ||
18 | use super::*; | ||
19 | |||
20 | impl ToChalk for hir_def::TraitId { | ||
21 | type Chalk = TraitId; | ||
22 | |||
23 | fn to_chalk(self, _db: &dyn HirDatabase) -> TraitId { | ||
24 | chalk_ir::TraitId(self.as_intern_id()) | ||
25 | } | ||
26 | |||
27 | fn from_chalk(_db: &dyn HirDatabase, trait_id: TraitId) -> hir_def::TraitId { | ||
28 | InternKey::from_intern_id(trait_id.0) | ||
29 | } | ||
30 | } | ||
31 | |||
32 | impl ToChalk for hir_def::ImplId { | ||
33 | type Chalk = ImplId; | ||
34 | |||
35 | fn to_chalk(self, _db: &dyn HirDatabase) -> ImplId { | ||
36 | chalk_ir::ImplId(self.as_intern_id()) | ||
37 | } | ||
38 | |||
39 | fn from_chalk(_db: &dyn HirDatabase, impl_id: ImplId) -> hir_def::ImplId { | ||
40 | InternKey::from_intern_id(impl_id.0) | ||
41 | } | ||
42 | } | ||
43 | |||
44 | impl ToChalk for CallableDefId { | ||
45 | type Chalk = FnDefId; | ||
46 | |||
47 | fn to_chalk(self, db: &dyn HirDatabase) -> FnDefId { | ||
48 | db.intern_callable_def(self).into() | ||
49 | } | ||
50 | |||
51 | fn from_chalk(db: &dyn HirDatabase, fn_def_id: FnDefId) -> CallableDefId { | ||
52 | db.lookup_intern_callable_def(fn_def_id.into()) | ||
53 | } | ||
54 | } | ||
55 | |||
56 | pub(crate) struct TypeAliasAsValue(pub(crate) TypeAliasId); | ||
57 | |||
58 | impl ToChalk for TypeAliasAsValue { | ||
59 | type Chalk = AssociatedTyValueId; | ||
60 | |||
61 | fn to_chalk(self, _db: &dyn HirDatabase) -> AssociatedTyValueId { | ||
62 | rust_ir::AssociatedTyValueId(self.0.as_intern_id()) | ||
63 | } | ||
64 | |||
65 | fn from_chalk( | ||
66 | _db: &dyn HirDatabase, | ||
67 | assoc_ty_value_id: AssociatedTyValueId, | ||
68 | ) -> TypeAliasAsValue { | ||
69 | TypeAliasAsValue(TypeAliasId::from_intern_id(assoc_ty_value_id.0)) | ||
70 | } | ||
71 | } | ||
72 | |||
73 | pub(super) fn convert_where_clauses( | ||
74 | db: &dyn HirDatabase, | ||
75 | def: GenericDefId, | ||
76 | substs: &Substitution, | ||
77 | ) -> Vec<chalk_ir::QuantifiedWhereClause<Interner>> { | ||
78 | let generic_predicates = db.generic_predicates(def); | ||
79 | let mut result = Vec::with_capacity(generic_predicates.len()); | ||
80 | for pred in generic_predicates.iter() { | ||
81 | result.push(pred.clone().substitute(&Interner, substs)); | ||
82 | } | ||
83 | result | ||
84 | } | ||
85 | |||
86 | pub(super) fn generic_predicate_to_inline_bound( | ||
87 | db: &dyn HirDatabase, | ||
88 | pred: &QuantifiedWhereClause, | ||
89 | self_ty: &Ty, | ||
90 | ) -> Option<chalk_ir::Binders<rust_ir::InlineBound<Interner>>> { | ||
91 | // An InlineBound is like a GenericPredicate, except the self type is left out. | ||
92 | // We don't have a special type for this, but Chalk does. | ||
93 | let self_ty_shifted_in = self_ty.clone().shifted_in_from(&Interner, DebruijnIndex::ONE); | ||
94 | let (pred, binders) = pred.as_ref().into_value_and_skipped_binders(); | ||
95 | match pred { | ||
96 | WhereClause::Implemented(trait_ref) => { | ||
97 | if trait_ref.self_type_parameter(&Interner) != self_ty_shifted_in { | ||
98 | // we can only convert predicates back to type bounds if they | ||
99 | // have the expected self type | ||
100 | return None; | ||
101 | } | ||
102 | let args_no_self = trait_ref.substitution.as_slice(&Interner)[1..] | ||
103 | .iter() | ||
104 | .map(|ty| ty.clone().cast(&Interner)) | ||
105 | .collect(); | ||
106 | let trait_bound = rust_ir::TraitBound { trait_id: trait_ref.trait_id, args_no_self }; | ||
107 | Some(chalk_ir::Binders::new(binders, rust_ir::InlineBound::TraitBound(trait_bound))) | ||
108 | } | ||
109 | WhereClause::AliasEq(AliasEq { alias: AliasTy::Projection(projection_ty), ty }) => { | ||
110 | if projection_ty.self_type_parameter(&Interner) != self_ty_shifted_in { | ||
111 | return None; | ||
112 | } | ||
113 | let trait_ = projection_ty.trait_(db); | ||
114 | let args_no_self = projection_ty.substitution.as_slice(&Interner)[1..] | ||
115 | .iter() | ||
116 | .map(|ty| ty.clone().cast(&Interner)) | ||
117 | .collect(); | ||
118 | let alias_eq_bound = rust_ir::AliasEqBound { | ||
119 | value: ty.clone(), | ||
120 | trait_bound: rust_ir::TraitBound { trait_id: trait_.to_chalk(db), args_no_self }, | ||
121 | associated_ty_id: projection_ty.associated_ty_id, | ||
122 | parameters: Vec::new(), // FIXME we don't support generic associated types yet | ||
123 | }; | ||
124 | Some(chalk_ir::Binders::new( | ||
125 | binders, | ||
126 | rust_ir::InlineBound::AliasEqBound(alias_eq_bound), | ||
127 | )) | ||
128 | } | ||
129 | _ => None, | ||
130 | } | ||
131 | } | ||
diff --git a/crates/hir_ty/src/traits/chalk/tls.rs b/crates/hir_ty/src/traits/chalk/tls.rs deleted file mode 100644 index 8892a63a9..000000000 --- a/crates/hir_ty/src/traits/chalk/tls.rs +++ /dev/null | |||
@@ -1,275 +0,0 @@ | |||
1 | //! Implementation of Chalk debug helper functions using TLS. | ||
2 | use std::fmt; | ||
3 | |||
4 | use chalk_ir::{AliasTy, GenericArg, Goal, Goals, Lifetime, ProgramClauseImplication}; | ||
5 | use itertools::Itertools; | ||
6 | |||
7 | use super::{from_chalk, Interner}; | ||
8 | use crate::{db::HirDatabase, from_assoc_type_id, CallableDefId}; | ||
9 | use hir_def::{AdtId, AssocContainerId, Lookup, TypeAliasId}; | ||
10 | |||
11 | pub(crate) use unsafe_tls::{set_current_program, with_current_program}; | ||
12 | |||
13 | pub(crate) struct DebugContext<'a>(&'a dyn HirDatabase); | ||
14 | |||
15 | impl DebugContext<'_> { | ||
16 | pub(crate) fn debug_struct_id( | ||
17 | &self, | ||
18 | id: super::AdtId, | ||
19 | f: &mut fmt::Formatter<'_>, | ||
20 | ) -> Result<(), fmt::Error> { | ||
21 | let name = match id.0 { | ||
22 | AdtId::StructId(it) => self.0.struct_data(it).name.clone(), | ||
23 | AdtId::UnionId(it) => self.0.union_data(it).name.clone(), | ||
24 | AdtId::EnumId(it) => self.0.enum_data(it).name.clone(), | ||
25 | }; | ||
26 | write!(f, "{}", name) | ||
27 | } | ||
28 | |||
29 | pub(crate) fn debug_trait_id( | ||
30 | &self, | ||
31 | id: super::TraitId, | ||
32 | fmt: &mut fmt::Formatter<'_>, | ||
33 | ) -> Result<(), fmt::Error> { | ||
34 | let trait_: hir_def::TraitId = from_chalk(self.0, id); | ||
35 | let trait_data = self.0.trait_data(trait_); | ||
36 | write!(fmt, "{}", trait_data.name) | ||
37 | } | ||
38 | |||
39 | pub(crate) fn debug_assoc_type_id( | ||
40 | &self, | ||
41 | id: super::AssocTypeId, | ||
42 | fmt: &mut fmt::Formatter<'_>, | ||
43 | ) -> Result<(), fmt::Error> { | ||
44 | let type_alias: TypeAliasId = from_assoc_type_id(id); | ||
45 | let type_alias_data = self.0.type_alias_data(type_alias); | ||
46 | let trait_ = match type_alias.lookup(self.0.upcast()).container { | ||
47 | AssocContainerId::TraitId(t) => t, | ||
48 | _ => panic!("associated type not in trait"), | ||
49 | }; | ||
50 | let trait_data = self.0.trait_data(trait_); | ||
51 | write!(fmt, "{}::{}", trait_data.name, type_alias_data.name) | ||
52 | } | ||
53 | |||
54 | pub(crate) fn debug_opaque_ty_id( | ||
55 | &self, | ||
56 | opaque_ty_id: chalk_ir::OpaqueTyId<Interner>, | ||
57 | fmt: &mut fmt::Formatter<'_>, | ||
58 | ) -> Result<(), fmt::Error> { | ||
59 | fmt.debug_struct("OpaqueTyId").field("index", &opaque_ty_id.0).finish() | ||
60 | } | ||
61 | |||
62 | pub(crate) fn debug_alias( | ||
63 | &self, | ||
64 | alias_ty: &AliasTy<Interner>, | ||
65 | fmt: &mut fmt::Formatter<'_>, | ||
66 | ) -> Result<(), fmt::Error> { | ||
67 | match alias_ty { | ||
68 | AliasTy::Projection(projection_ty) => self.debug_projection_ty(projection_ty, fmt), | ||
69 | AliasTy::Opaque(opaque_ty) => self.debug_opaque_ty(opaque_ty, fmt), | ||
70 | } | ||
71 | } | ||
72 | |||
73 | pub(crate) fn debug_projection_ty( | ||
74 | &self, | ||
75 | projection_ty: &chalk_ir::ProjectionTy<Interner>, | ||
76 | fmt: &mut fmt::Formatter<'_>, | ||
77 | ) -> Result<(), fmt::Error> { | ||
78 | let type_alias = from_assoc_type_id(projection_ty.associated_ty_id); | ||
79 | let type_alias_data = self.0.type_alias_data(type_alias); | ||
80 | let trait_ = match type_alias.lookup(self.0.upcast()).container { | ||
81 | AssocContainerId::TraitId(t) => t, | ||
82 | _ => panic!("associated type not in trait"), | ||
83 | }; | ||
84 | let trait_data = self.0.trait_data(trait_); | ||
85 | let params = projection_ty.substitution.as_slice(&Interner); | ||
86 | write!(fmt, "<{:?} as {}", ¶ms[0], trait_data.name,)?; | ||
87 | if params.len() > 1 { | ||
88 | write!( | ||
89 | fmt, | ||
90 | "<{}>", | ||
91 | ¶ms[1..].iter().format_with(", ", |x, f| f(&format_args!("{:?}", x))), | ||
92 | )?; | ||
93 | } | ||
94 | write!(fmt, ">::{}", type_alias_data.name) | ||
95 | } | ||
96 | |||
97 | pub(crate) fn debug_opaque_ty( | ||
98 | &self, | ||
99 | opaque_ty: &chalk_ir::OpaqueTy<Interner>, | ||
100 | fmt: &mut fmt::Formatter<'_>, | ||
101 | ) -> Result<(), fmt::Error> { | ||
102 | write!(fmt, "{:?}", opaque_ty.opaque_ty_id) | ||
103 | } | ||
104 | |||
105 | pub(crate) fn debug_ty( | ||
106 | &self, | ||
107 | ty: &chalk_ir::Ty<Interner>, | ||
108 | fmt: &mut fmt::Formatter<'_>, | ||
109 | ) -> Result<(), fmt::Error> { | ||
110 | write!(fmt, "{:?}", ty.data(&Interner)) | ||
111 | } | ||
112 | |||
113 | pub(crate) fn debug_lifetime( | ||
114 | &self, | ||
115 | lifetime: &Lifetime<Interner>, | ||
116 | fmt: &mut fmt::Formatter<'_>, | ||
117 | ) -> Result<(), fmt::Error> { | ||
118 | write!(fmt, "{:?}", lifetime.data(&Interner)) | ||
119 | } | ||
120 | |||
121 | pub(crate) fn debug_generic_arg( | ||
122 | &self, | ||
123 | parameter: &GenericArg<Interner>, | ||
124 | fmt: &mut fmt::Formatter<'_>, | ||
125 | ) -> Result<(), fmt::Error> { | ||
126 | write!(fmt, "{:?}", parameter.data(&Interner).inner_debug()) | ||
127 | } | ||
128 | |||
129 | pub(crate) fn debug_goal( | ||
130 | &self, | ||
131 | goal: &Goal<Interner>, | ||
132 | fmt: &mut fmt::Formatter<'_>, | ||
133 | ) -> Result<(), fmt::Error> { | ||
134 | let goal_data = goal.data(&Interner); | ||
135 | write!(fmt, "{:?}", goal_data) | ||
136 | } | ||
137 | |||
138 | pub(crate) fn debug_goals( | ||
139 | &self, | ||
140 | goals: &Goals<Interner>, | ||
141 | fmt: &mut fmt::Formatter<'_>, | ||
142 | ) -> Result<(), fmt::Error> { | ||
143 | write!(fmt, "{:?}", goals.debug(&Interner)) | ||
144 | } | ||
145 | |||
146 | pub(crate) fn debug_program_clause_implication( | ||
147 | &self, | ||
148 | pci: &ProgramClauseImplication<Interner>, | ||
149 | fmt: &mut fmt::Formatter<'_>, | ||
150 | ) -> Result<(), fmt::Error> { | ||
151 | write!(fmt, "{:?}", pci.debug(&Interner)) | ||
152 | } | ||
153 | |||
154 | pub(crate) fn debug_substitution( | ||
155 | &self, | ||
156 | substitution: &chalk_ir::Substitution<Interner>, | ||
157 | fmt: &mut fmt::Formatter<'_>, | ||
158 | ) -> Result<(), fmt::Error> { | ||
159 | write!(fmt, "{:?}", substitution.debug(&Interner)) | ||
160 | } | ||
161 | |||
162 | pub(crate) fn debug_separator_trait_ref( | ||
163 | &self, | ||
164 | separator_trait_ref: &chalk_ir::SeparatorTraitRef<Interner>, | ||
165 | fmt: &mut fmt::Formatter<'_>, | ||
166 | ) -> Result<(), fmt::Error> { | ||
167 | write!(fmt, "{:?}", separator_trait_ref.debug(&Interner)) | ||
168 | } | ||
169 | |||
170 | pub(crate) fn debug_fn_def_id( | ||
171 | &self, | ||
172 | fn_def_id: chalk_ir::FnDefId<Interner>, | ||
173 | fmt: &mut fmt::Formatter<'_>, | ||
174 | ) -> Result<(), fmt::Error> { | ||
175 | let def: CallableDefId = from_chalk(self.0, fn_def_id); | ||
176 | let name = match def { | ||
177 | CallableDefId::FunctionId(ff) => self.0.function_data(ff).name.clone(), | ||
178 | CallableDefId::StructId(s) => self.0.struct_data(s).name.clone(), | ||
179 | CallableDefId::EnumVariantId(e) => { | ||
180 | let enum_data = self.0.enum_data(e.parent); | ||
181 | enum_data.variants[e.local_id].name.clone() | ||
182 | } | ||
183 | }; | ||
184 | match def { | ||
185 | CallableDefId::FunctionId(_) => write!(fmt, "{{fn {}}}", name), | ||
186 | CallableDefId::StructId(_) | CallableDefId::EnumVariantId(_) => { | ||
187 | write!(fmt, "{{ctor {}}}", name) | ||
188 | } | ||
189 | } | ||
190 | } | ||
191 | |||
192 | pub(crate) fn debug_const( | ||
193 | &self, | ||
194 | _constant: &chalk_ir::Const<Interner>, | ||
195 | fmt: &mut fmt::Formatter<'_>, | ||
196 | ) -> fmt::Result { | ||
197 | write!(fmt, "const") | ||
198 | } | ||
199 | |||
200 | pub(crate) fn debug_variable_kinds( | ||
201 | &self, | ||
202 | variable_kinds: &chalk_ir::VariableKinds<Interner>, | ||
203 | fmt: &mut fmt::Formatter<'_>, | ||
204 | ) -> fmt::Result { | ||
205 | write!(fmt, "{:?}", variable_kinds.as_slice(&Interner)) | ||
206 | } | ||
207 | pub(crate) fn debug_variable_kinds_with_angles( | ||
208 | &self, | ||
209 | variable_kinds: &chalk_ir::VariableKinds<Interner>, | ||
210 | fmt: &mut fmt::Formatter<'_>, | ||
211 | ) -> fmt::Result { | ||
212 | write!(fmt, "{:?}", variable_kinds.inner_debug(&Interner)) | ||
213 | } | ||
214 | pub(crate) fn debug_canonical_var_kinds( | ||
215 | &self, | ||
216 | canonical_var_kinds: &chalk_ir::CanonicalVarKinds<Interner>, | ||
217 | fmt: &mut fmt::Formatter<'_>, | ||
218 | ) -> fmt::Result { | ||
219 | write!(fmt, "{:?}", canonical_var_kinds.as_slice(&Interner)) | ||
220 | } | ||
221 | pub(crate) fn debug_program_clause( | ||
222 | &self, | ||
223 | clause: &chalk_ir::ProgramClause<Interner>, | ||
224 | fmt: &mut fmt::Formatter<'_>, | ||
225 | ) -> fmt::Result { | ||
226 | write!(fmt, "{:?}", clause.data(&Interner)) | ||
227 | } | ||
228 | pub(crate) fn debug_program_clauses( | ||
229 | &self, | ||
230 | clauses: &chalk_ir::ProgramClauses<Interner>, | ||
231 | fmt: &mut fmt::Formatter<'_>, | ||
232 | ) -> fmt::Result { | ||
233 | write!(fmt, "{:?}", clauses.as_slice(&Interner)) | ||
234 | } | ||
235 | pub(crate) fn debug_quantified_where_clauses( | ||
236 | &self, | ||
237 | clauses: &chalk_ir::QuantifiedWhereClauses<Interner>, | ||
238 | fmt: &mut fmt::Formatter<'_>, | ||
239 | ) -> fmt::Result { | ||
240 | write!(fmt, "{:?}", clauses.as_slice(&Interner)) | ||
241 | } | ||
242 | } | ||
243 | |||
244 | mod unsafe_tls { | ||
245 | use super::DebugContext; | ||
246 | use crate::db::HirDatabase; | ||
247 | use scoped_tls::scoped_thread_local; | ||
248 | |||
249 | scoped_thread_local!(static PROGRAM: DebugContext); | ||
250 | |||
251 | pub(crate) fn with_current_program<R>( | ||
252 | op: impl for<'a> FnOnce(Option<&'a DebugContext<'a>>) -> R, | ||
253 | ) -> R { | ||
254 | if PROGRAM.is_set() { | ||
255 | PROGRAM.with(|prog| op(Some(prog))) | ||
256 | } else { | ||
257 | op(None) | ||
258 | } | ||
259 | } | ||
260 | |||
261 | pub(crate) fn set_current_program<OP, R>(p: &dyn HirDatabase, op: OP) -> R | ||
262 | where | ||
263 | OP: FnOnce() -> R, | ||
264 | { | ||
265 | let ctx = DebugContext(p); | ||
266 | // we're transmuting the lifetime in the DebugContext to static. This is | ||
267 | // fine because we only keep the reference for the lifetime of this | ||
268 | // function, *and* the only way to access the context is through | ||
269 | // `with_current_program`, which hides the lifetime through the `for` | ||
270 | // type. | ||
271 | let static_p: &DebugContext<'static> = | ||
272 | unsafe { std::mem::transmute::<&DebugContext, &DebugContext<'static>>(&ctx) }; | ||
273 | PROGRAM.set(static_p, || op()) | ||
274 | } | ||
275 | } | ||