diff options
author | bors[bot] <26634292+bors[bot]@users.noreply.github.com> | 2020-05-22 19:16:28 +0100 |
---|---|---|
committer | GitHub <[email protected]> | 2020-05-22 19:16:28 +0100 |
commit | d4daca9f02ec46be1beef79e9ed647a3a24e2434 (patch) | |
tree | f9875be8e240fd2d339e00b77035713f85660a4e /crates/ra_hir_ty/src/traits/chalk/mapping.rs | |
parent | b38f9a5810f28563c45acb1ae8b82438649227c9 (diff) | |
parent | ea265aad64366340fa7986f7f93488300631168c (diff) |
Merge #4573
4573: Chalk cleanups r=matklad a=flodiebold
- split off the `Interner` impl and the conversion code into their own modules
- use `TypeCtorId` as `AdtId` directly (instead of raw `InternId`s), and rename the type alias `StructId` -> `AdtId`
- provide missing Chalk debug impls
Co-authored-by: Florian Diebold <[email protected]>
Diffstat (limited to 'crates/ra_hir_ty/src/traits/chalk/mapping.rs')
-rw-r--r-- | crates/ra_hir_ty/src/traits/chalk/mapping.rs | 672 |
1 files changed, 672 insertions, 0 deletions
diff --git a/crates/ra_hir_ty/src/traits/chalk/mapping.rs b/crates/ra_hir_ty/src/traits/chalk/mapping.rs new file mode 100644 index 000000000..a83d82fd8 --- /dev/null +++ b/crates/ra_hir_ty/src/traits/chalk/mapping.rs | |||
@@ -0,0 +1,672 @@ | |||
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::{ | ||
7 | cast::Cast, fold::shift::Shift, interner::HasInterner, PlaceholderIndex, Scalar, TypeName, | ||
8 | UniverseIndex, | ||
9 | }; | ||
10 | |||
11 | use hir_def::{type_ref::Mutability, AssocContainerId, GenericDefId, Lookup, TypeAliasId}; | ||
12 | use ra_db::salsa::InternKey; | ||
13 | |||
14 | use crate::{ | ||
15 | db::HirDatabase, | ||
16 | primitive::{FloatBitness, FloatTy, IntBitness, IntTy, Signedness, Uncertain}, | ||
17 | traits::{builtin, AssocTyValue, Canonical, Impl, Obligation}, | ||
18 | ApplicationTy, GenericPredicate, InEnvironment, ProjectionPredicate, ProjectionTy, Substs, | ||
19 | TraitEnvironment, TraitRef, Ty, TypeCtor, | ||
20 | }; | ||
21 | |||
22 | use super::interner::*; | ||
23 | use super::*; | ||
24 | |||
25 | impl ToChalk for Ty { | ||
26 | type Chalk = chalk_ir::Ty<Interner>; | ||
27 | fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::Ty<Interner> { | ||
28 | match self { | ||
29 | Ty::Apply(apply_ty) => { | ||
30 | if let TypeCtor::Ref(m) = apply_ty.ctor { | ||
31 | return ref_to_chalk(db, m, apply_ty.parameters); | ||
32 | } | ||
33 | let name = apply_ty.ctor.to_chalk(db); | ||
34 | let substitution = apply_ty.parameters.to_chalk(db); | ||
35 | chalk_ir::ApplicationTy { name, substitution }.cast(&Interner).intern(&Interner) | ||
36 | } | ||
37 | Ty::Projection(proj_ty) => { | ||
38 | let associated_ty_id = proj_ty.associated_ty.to_chalk(db); | ||
39 | let substitution = proj_ty.parameters.to_chalk(db); | ||
40 | chalk_ir::AliasTy::Projection(chalk_ir::ProjectionTy { | ||
41 | associated_ty_id, | ||
42 | substitution, | ||
43 | }) | ||
44 | .cast(&Interner) | ||
45 | .intern(&Interner) | ||
46 | } | ||
47 | Ty::Placeholder(id) => { | ||
48 | let interned_id = db.intern_type_param_id(id); | ||
49 | PlaceholderIndex { | ||
50 | ui: UniverseIndex::ROOT, | ||
51 | idx: interned_id.as_intern_id().as_usize(), | ||
52 | } | ||
53 | .to_ty::<Interner>(&Interner) | ||
54 | } | ||
55 | Ty::Bound(idx) => chalk_ir::TyData::BoundVar(idx).intern(&Interner), | ||
56 | Ty::Infer(_infer_ty) => panic!("uncanonicalized infer ty"), | ||
57 | Ty::Dyn(predicates) => { | ||
58 | let where_clauses = chalk_ir::QuantifiedWhereClauses::from( | ||
59 | &Interner, | ||
60 | predicates.iter().filter(|p| !p.is_error()).cloned().map(|p| p.to_chalk(db)), | ||
61 | ); | ||
62 | let bounded_ty = chalk_ir::DynTy { bounds: make_binders(where_clauses, 1) }; | ||
63 | chalk_ir::TyData::Dyn(bounded_ty).intern(&Interner) | ||
64 | } | ||
65 | Ty::Opaque(_) | Ty::Unknown => { | ||
66 | let substitution = chalk_ir::Substitution::empty(&Interner); | ||
67 | let name = TypeName::Error; | ||
68 | chalk_ir::ApplicationTy { name, substitution }.cast(&Interner).intern(&Interner) | ||
69 | } | ||
70 | } | ||
71 | } | ||
72 | fn from_chalk(db: &dyn HirDatabase, chalk: chalk_ir::Ty<Interner>) -> Self { | ||
73 | match chalk.data(&Interner).clone() { | ||
74 | chalk_ir::TyData::Apply(apply_ty) => match apply_ty.name { | ||
75 | TypeName::Error => Ty::Unknown, | ||
76 | TypeName::Ref(m) => ref_from_chalk(db, m, apply_ty.substitution), | ||
77 | _ => { | ||
78 | let ctor = from_chalk(db, apply_ty.name); | ||
79 | let parameters = from_chalk(db, apply_ty.substitution); | ||
80 | Ty::Apply(ApplicationTy { ctor, parameters }) | ||
81 | } | ||
82 | }, | ||
83 | chalk_ir::TyData::Placeholder(idx) => { | ||
84 | assert_eq!(idx.ui, UniverseIndex::ROOT); | ||
85 | let interned_id = crate::db::GlobalTypeParamId::from_intern_id( | ||
86 | crate::salsa::InternId::from(idx.idx), | ||
87 | ); | ||
88 | Ty::Placeholder(db.lookup_intern_type_param_id(interned_id)) | ||
89 | } | ||
90 | chalk_ir::TyData::Alias(chalk_ir::AliasTy::Projection(proj)) => { | ||
91 | let associated_ty = from_chalk(db, proj.associated_ty_id); | ||
92 | let parameters = from_chalk(db, proj.substitution); | ||
93 | Ty::Projection(ProjectionTy { associated_ty, parameters }) | ||
94 | } | ||
95 | chalk_ir::TyData::Alias(chalk_ir::AliasTy::Opaque(_)) => unimplemented!(), | ||
96 | chalk_ir::TyData::Function(_) => unimplemented!(), | ||
97 | chalk_ir::TyData::BoundVar(idx) => Ty::Bound(idx), | ||
98 | chalk_ir::TyData::InferenceVar(_iv) => Ty::Unknown, | ||
99 | chalk_ir::TyData::Dyn(where_clauses) => { | ||
100 | assert_eq!(where_clauses.bounds.binders.len(&Interner), 1); | ||
101 | let predicates = where_clauses | ||
102 | .bounds | ||
103 | .skip_binders() | ||
104 | .iter(&Interner) | ||
105 | .map(|c| from_chalk(db, c.clone())) | ||
106 | .collect(); | ||
107 | Ty::Dyn(predicates) | ||
108 | } | ||
109 | } | ||
110 | } | ||
111 | } | ||
112 | |||
113 | const LIFETIME_PLACEHOLDER: PlaceholderIndex = | ||
114 | PlaceholderIndex { ui: UniverseIndex::ROOT, idx: usize::MAX }; | ||
115 | |||
116 | /// We currently don't model lifetimes, but Chalk does. So, we have to insert a | ||
117 | /// fake lifetime here, because Chalks built-in logic may expect it to be there. | ||
118 | fn ref_to_chalk( | ||
119 | db: &dyn HirDatabase, | ||
120 | mutability: Mutability, | ||
121 | subst: Substs, | ||
122 | ) -> chalk_ir::Ty<Interner> { | ||
123 | let arg = subst[0].clone().to_chalk(db); | ||
124 | let lifetime = LIFETIME_PLACEHOLDER.to_lifetime(&Interner); | ||
125 | chalk_ir::ApplicationTy { | ||
126 | name: TypeName::Ref(mutability.to_chalk(db)), | ||
127 | substitution: chalk_ir::Substitution::from( | ||
128 | &Interner, | ||
129 | vec![lifetime.cast(&Interner), arg.cast(&Interner)], | ||
130 | ), | ||
131 | } | ||
132 | .intern(&Interner) | ||
133 | } | ||
134 | |||
135 | /// Here we remove the lifetime from the type we got from Chalk. | ||
136 | fn ref_from_chalk( | ||
137 | db: &dyn HirDatabase, | ||
138 | mutability: chalk_ir::Mutability, | ||
139 | subst: chalk_ir::Substitution<Interner>, | ||
140 | ) -> Ty { | ||
141 | let tys = subst | ||
142 | .iter(&Interner) | ||
143 | .filter_map(|p| Some(from_chalk(db, p.ty(&Interner)?.clone()))) | ||
144 | .collect(); | ||
145 | Ty::apply(TypeCtor::Ref(from_chalk(db, mutability)), Substs(tys)) | ||
146 | } | ||
147 | |||
148 | impl ToChalk for Substs { | ||
149 | type Chalk = chalk_ir::Substitution<Interner>; | ||
150 | |||
151 | fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::Substitution<Interner> { | ||
152 | chalk_ir::Substitution::from(&Interner, self.iter().map(|ty| ty.clone().to_chalk(db))) | ||
153 | } | ||
154 | |||
155 | fn from_chalk(db: &dyn HirDatabase, parameters: chalk_ir::Substitution<Interner>) -> Substs { | ||
156 | let tys = parameters | ||
157 | .iter(&Interner) | ||
158 | .map(|p| match p.ty(&Interner) { | ||
159 | Some(ty) => from_chalk(db, ty.clone()), | ||
160 | None => unimplemented!(), | ||
161 | }) | ||
162 | .collect(); | ||
163 | Substs(tys) | ||
164 | } | ||
165 | } | ||
166 | |||
167 | impl ToChalk for TraitRef { | ||
168 | type Chalk = chalk_ir::TraitRef<Interner>; | ||
169 | |||
170 | fn to_chalk(self: TraitRef, db: &dyn HirDatabase) -> chalk_ir::TraitRef<Interner> { | ||
171 | let trait_id = self.trait_.to_chalk(db); | ||
172 | let substitution = self.substs.to_chalk(db); | ||
173 | chalk_ir::TraitRef { trait_id, substitution } | ||
174 | } | ||
175 | |||
176 | fn from_chalk(db: &dyn HirDatabase, trait_ref: chalk_ir::TraitRef<Interner>) -> Self { | ||
177 | let trait_ = from_chalk(db, trait_ref.trait_id); | ||
178 | let substs = from_chalk(db, trait_ref.substitution); | ||
179 | TraitRef { trait_, substs } | ||
180 | } | ||
181 | } | ||
182 | |||
183 | impl ToChalk for hir_def::TraitId { | ||
184 | type Chalk = TraitId; | ||
185 | |||
186 | fn to_chalk(self, _db: &dyn HirDatabase) -> TraitId { | ||
187 | chalk_ir::TraitId(self.as_intern_id()) | ||
188 | } | ||
189 | |||
190 | fn from_chalk(_db: &dyn HirDatabase, trait_id: TraitId) -> hir_def::TraitId { | ||
191 | InternKey::from_intern_id(trait_id.0) | ||
192 | } | ||
193 | } | ||
194 | |||
195 | impl ToChalk for TypeCtor { | ||
196 | type Chalk = TypeName<Interner>; | ||
197 | |||
198 | fn to_chalk(self, db: &dyn HirDatabase) -> TypeName<Interner> { | ||
199 | match self { | ||
200 | TypeCtor::AssociatedType(type_alias) => { | ||
201 | let type_id = type_alias.to_chalk(db); | ||
202 | TypeName::AssociatedType(type_id) | ||
203 | } | ||
204 | |||
205 | TypeCtor::Bool => TypeName::Scalar(Scalar::Bool), | ||
206 | TypeCtor::Char => TypeName::Scalar(Scalar::Char), | ||
207 | TypeCtor::Int(Uncertain::Known(int_ty)) => TypeName::Scalar(int_ty_to_chalk(int_ty)), | ||
208 | TypeCtor::Float(Uncertain::Known(FloatTy { bitness: FloatBitness::X32 })) => { | ||
209 | TypeName::Scalar(Scalar::Float(chalk_ir::FloatTy::F32)) | ||
210 | } | ||
211 | TypeCtor::Float(Uncertain::Known(FloatTy { bitness: FloatBitness::X64 })) => { | ||
212 | TypeName::Scalar(Scalar::Float(chalk_ir::FloatTy::F64)) | ||
213 | } | ||
214 | |||
215 | TypeCtor::Tuple { cardinality } => TypeName::Tuple(cardinality.into()), | ||
216 | TypeCtor::RawPtr(mutability) => TypeName::Raw(mutability.to_chalk(db)), | ||
217 | TypeCtor::Slice => TypeName::Slice, | ||
218 | TypeCtor::Ref(mutability) => TypeName::Ref(mutability.to_chalk(db)), | ||
219 | TypeCtor::Str => TypeName::Str, | ||
220 | TypeCtor::Int(Uncertain::Unknown) | ||
221 | | TypeCtor::Float(Uncertain::Unknown) | ||
222 | | TypeCtor::Adt(_) | ||
223 | | TypeCtor::Array | ||
224 | | TypeCtor::FnDef(_) | ||
225 | | TypeCtor::FnPtr { .. } | ||
226 | | TypeCtor::Never | ||
227 | | TypeCtor::Closure { .. } => { | ||
228 | // other TypeCtors get interned and turned into a chalk StructId | ||
229 | let struct_id = db.intern_type_ctor(self).into(); | ||
230 | TypeName::Adt(struct_id) | ||
231 | } | ||
232 | } | ||
233 | } | ||
234 | |||
235 | fn from_chalk(db: &dyn HirDatabase, type_name: TypeName<Interner>) -> TypeCtor { | ||
236 | match type_name { | ||
237 | TypeName::Adt(struct_id) => db.lookup_intern_type_ctor(struct_id.into()), | ||
238 | TypeName::AssociatedType(type_id) => TypeCtor::AssociatedType(from_chalk(db, type_id)), | ||
239 | TypeName::OpaqueType(_) => unreachable!(), | ||
240 | |||
241 | TypeName::Scalar(Scalar::Bool) => TypeCtor::Bool, | ||
242 | TypeName::Scalar(Scalar::Char) => TypeCtor::Char, | ||
243 | TypeName::Scalar(Scalar::Int(int_ty)) => TypeCtor::Int(Uncertain::Known(IntTy { | ||
244 | signedness: Signedness::Signed, | ||
245 | bitness: bitness_from_chalk_int(int_ty), | ||
246 | })), | ||
247 | TypeName::Scalar(Scalar::Uint(uint_ty)) => TypeCtor::Int(Uncertain::Known(IntTy { | ||
248 | signedness: Signedness::Unsigned, | ||
249 | bitness: bitness_from_chalk_uint(uint_ty), | ||
250 | })), | ||
251 | TypeName::Scalar(Scalar::Float(chalk_ir::FloatTy::F32)) => { | ||
252 | TypeCtor::Float(Uncertain::Known(FloatTy { bitness: FloatBitness::X32 })) | ||
253 | } | ||
254 | TypeName::Scalar(Scalar::Float(chalk_ir::FloatTy::F64)) => { | ||
255 | TypeCtor::Float(Uncertain::Known(FloatTy { bitness: FloatBitness::X64 })) | ||
256 | } | ||
257 | TypeName::Tuple(cardinality) => TypeCtor::Tuple { cardinality: cardinality as u16 }, | ||
258 | TypeName::Raw(mutability) => TypeCtor::RawPtr(from_chalk(db, mutability)), | ||
259 | TypeName::Slice => TypeCtor::Slice, | ||
260 | TypeName::Ref(mutability) => TypeCtor::Ref(from_chalk(db, mutability)), | ||
261 | TypeName::Str => TypeCtor::Str, | ||
262 | |||
263 | TypeName::FnDef(_) => unreachable!(), | ||
264 | |||
265 | TypeName::Error => { | ||
266 | // this should not be reached, since we don't represent TypeName::Error with TypeCtor | ||
267 | unreachable!() | ||
268 | } | ||
269 | } | ||
270 | } | ||
271 | } | ||
272 | |||
273 | fn bitness_from_chalk_uint(uint_ty: chalk_ir::UintTy) -> IntBitness { | ||
274 | use chalk_ir::UintTy; | ||
275 | |||
276 | match uint_ty { | ||
277 | UintTy::Usize => IntBitness::Xsize, | ||
278 | UintTy::U8 => IntBitness::X8, | ||
279 | UintTy::U16 => IntBitness::X16, | ||
280 | UintTy::U32 => IntBitness::X32, | ||
281 | UintTy::U64 => IntBitness::X64, | ||
282 | UintTy::U128 => IntBitness::X128, | ||
283 | } | ||
284 | } | ||
285 | |||
286 | fn bitness_from_chalk_int(int_ty: chalk_ir::IntTy) -> IntBitness { | ||
287 | use chalk_ir::IntTy; | ||
288 | |||
289 | match int_ty { | ||
290 | IntTy::Isize => IntBitness::Xsize, | ||
291 | IntTy::I8 => IntBitness::X8, | ||
292 | IntTy::I16 => IntBitness::X16, | ||
293 | IntTy::I32 => IntBitness::X32, | ||
294 | IntTy::I64 => IntBitness::X64, | ||
295 | IntTy::I128 => IntBitness::X128, | ||
296 | } | ||
297 | } | ||
298 | |||
299 | fn int_ty_to_chalk(int_ty: IntTy) -> Scalar { | ||
300 | use chalk_ir::{IntTy, UintTy}; | ||
301 | |||
302 | match int_ty.signedness { | ||
303 | Signedness::Signed => Scalar::Int(match int_ty.bitness { | ||
304 | IntBitness::Xsize => IntTy::Isize, | ||
305 | IntBitness::X8 => IntTy::I8, | ||
306 | IntBitness::X16 => IntTy::I16, | ||
307 | IntBitness::X32 => IntTy::I32, | ||
308 | IntBitness::X64 => IntTy::I64, | ||
309 | IntBitness::X128 => IntTy::I128, | ||
310 | }), | ||
311 | Signedness::Unsigned => Scalar::Uint(match int_ty.bitness { | ||
312 | IntBitness::Xsize => UintTy::Usize, | ||
313 | IntBitness::X8 => UintTy::U8, | ||
314 | IntBitness::X16 => UintTy::U16, | ||
315 | IntBitness::X32 => UintTy::U32, | ||
316 | IntBitness::X64 => UintTy::U64, | ||
317 | IntBitness::X128 => UintTy::U128, | ||
318 | }), | ||
319 | } | ||
320 | } | ||
321 | |||
322 | impl ToChalk for Mutability { | ||
323 | type Chalk = chalk_ir::Mutability; | ||
324 | fn to_chalk(self, _db: &dyn HirDatabase) -> Self::Chalk { | ||
325 | match self { | ||
326 | Mutability::Shared => chalk_ir::Mutability::Not, | ||
327 | Mutability::Mut => chalk_ir::Mutability::Mut, | ||
328 | } | ||
329 | } | ||
330 | fn from_chalk(_db: &dyn HirDatabase, chalk: Self::Chalk) -> Self { | ||
331 | match chalk { | ||
332 | chalk_ir::Mutability::Mut => Mutability::Mut, | ||
333 | chalk_ir::Mutability::Not => Mutability::Shared, | ||
334 | } | ||
335 | } | ||
336 | } | ||
337 | |||
338 | impl ToChalk for Impl { | ||
339 | type Chalk = ImplId; | ||
340 | |||
341 | fn to_chalk(self, db: &dyn HirDatabase) -> ImplId { | ||
342 | db.intern_chalk_impl(self).into() | ||
343 | } | ||
344 | |||
345 | fn from_chalk(db: &dyn HirDatabase, impl_id: ImplId) -> Impl { | ||
346 | db.lookup_intern_chalk_impl(impl_id.into()) | ||
347 | } | ||
348 | } | ||
349 | |||
350 | impl ToChalk for TypeAliasId { | ||
351 | type Chalk = AssocTypeId; | ||
352 | |||
353 | fn to_chalk(self, _db: &dyn HirDatabase) -> AssocTypeId { | ||
354 | chalk_ir::AssocTypeId(self.as_intern_id()) | ||
355 | } | ||
356 | |||
357 | fn from_chalk(_db: &dyn HirDatabase, type_alias_id: AssocTypeId) -> TypeAliasId { | ||
358 | InternKey::from_intern_id(type_alias_id.0) | ||
359 | } | ||
360 | } | ||
361 | |||
362 | impl ToChalk for AssocTyValue { | ||
363 | type Chalk = AssociatedTyValueId; | ||
364 | |||
365 | fn to_chalk(self, db: &dyn HirDatabase) -> AssociatedTyValueId { | ||
366 | db.intern_assoc_ty_value(self).into() | ||
367 | } | ||
368 | |||
369 | fn from_chalk(db: &dyn HirDatabase, assoc_ty_value_id: AssociatedTyValueId) -> AssocTyValue { | ||
370 | db.lookup_intern_assoc_ty_value(assoc_ty_value_id.into()) | ||
371 | } | ||
372 | } | ||
373 | |||
374 | impl ToChalk for GenericPredicate { | ||
375 | type Chalk = chalk_ir::QuantifiedWhereClause<Interner>; | ||
376 | |||
377 | fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::QuantifiedWhereClause<Interner> { | ||
378 | match self { | ||
379 | GenericPredicate::Implemented(trait_ref) => { | ||
380 | let chalk_trait_ref = trait_ref.to_chalk(db); | ||
381 | let chalk_trait_ref = chalk_trait_ref.shifted_in(&Interner); | ||
382 | make_binders(chalk_ir::WhereClause::Implemented(chalk_trait_ref), 0) | ||
383 | } | ||
384 | GenericPredicate::Projection(projection_pred) => { | ||
385 | let ty = projection_pred.ty.to_chalk(db).shifted_in(&Interner); | ||
386 | let projection = projection_pred.projection_ty.to_chalk(db).shifted_in(&Interner); | ||
387 | let alias = chalk_ir::AliasTy::Projection(projection); | ||
388 | make_binders(chalk_ir::WhereClause::AliasEq(chalk_ir::AliasEq { alias, ty }), 0) | ||
389 | } | ||
390 | GenericPredicate::Error => panic!("tried passing GenericPredicate::Error to Chalk"), | ||
391 | } | ||
392 | } | ||
393 | |||
394 | fn from_chalk( | ||
395 | db: &dyn HirDatabase, | ||
396 | where_clause: chalk_ir::QuantifiedWhereClause<Interner>, | ||
397 | ) -> GenericPredicate { | ||
398 | // we don't produce any where clauses with binders and can't currently deal with them | ||
399 | match where_clause | ||
400 | .skip_binders() | ||
401 | .shifted_out(&Interner) | ||
402 | .expect("unexpected bound vars in where clause") | ||
403 | { | ||
404 | chalk_ir::WhereClause::Implemented(tr) => { | ||
405 | GenericPredicate::Implemented(from_chalk(db, tr)) | ||
406 | } | ||
407 | chalk_ir::WhereClause::AliasEq(projection_eq) => { | ||
408 | let projection_ty = from_chalk( | ||
409 | db, | ||
410 | match projection_eq.alias { | ||
411 | chalk_ir::AliasTy::Projection(p) => p, | ||
412 | _ => unimplemented!(), | ||
413 | }, | ||
414 | ); | ||
415 | let ty = from_chalk(db, projection_eq.ty); | ||
416 | GenericPredicate::Projection(ProjectionPredicate { projection_ty, ty }) | ||
417 | } | ||
418 | } | ||
419 | } | ||
420 | } | ||
421 | |||
422 | impl ToChalk for ProjectionTy { | ||
423 | type Chalk = chalk_ir::ProjectionTy<Interner>; | ||
424 | |||
425 | fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::ProjectionTy<Interner> { | ||
426 | chalk_ir::ProjectionTy { | ||
427 | associated_ty_id: self.associated_ty.to_chalk(db), | ||
428 | substitution: self.parameters.to_chalk(db), | ||
429 | } | ||
430 | } | ||
431 | |||
432 | fn from_chalk( | ||
433 | db: &dyn HirDatabase, | ||
434 | projection_ty: chalk_ir::ProjectionTy<Interner>, | ||
435 | ) -> ProjectionTy { | ||
436 | ProjectionTy { | ||
437 | associated_ty: from_chalk(db, projection_ty.associated_ty_id), | ||
438 | parameters: from_chalk(db, projection_ty.substitution), | ||
439 | } | ||
440 | } | ||
441 | } | ||
442 | |||
443 | impl ToChalk for ProjectionPredicate { | ||
444 | type Chalk = chalk_ir::AliasEq<Interner>; | ||
445 | |||
446 | fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::AliasEq<Interner> { | ||
447 | chalk_ir::AliasEq { | ||
448 | alias: chalk_ir::AliasTy::Projection(self.projection_ty.to_chalk(db)), | ||
449 | ty: self.ty.to_chalk(db), | ||
450 | } | ||
451 | } | ||
452 | |||
453 | fn from_chalk(_db: &dyn HirDatabase, _normalize: chalk_ir::AliasEq<Interner>) -> Self { | ||
454 | unimplemented!() | ||
455 | } | ||
456 | } | ||
457 | |||
458 | impl ToChalk for Obligation { | ||
459 | type Chalk = chalk_ir::DomainGoal<Interner>; | ||
460 | |||
461 | fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::DomainGoal<Interner> { | ||
462 | match self { | ||
463 | Obligation::Trait(tr) => tr.to_chalk(db).cast(&Interner), | ||
464 | Obligation::Projection(pr) => pr.to_chalk(db).cast(&Interner), | ||
465 | } | ||
466 | } | ||
467 | |||
468 | fn from_chalk(_db: &dyn HirDatabase, _goal: chalk_ir::DomainGoal<Interner>) -> Self { | ||
469 | unimplemented!() | ||
470 | } | ||
471 | } | ||
472 | |||
473 | impl<T> ToChalk for Canonical<T> | ||
474 | where | ||
475 | T: ToChalk, | ||
476 | T::Chalk: HasInterner<Interner = Interner>, | ||
477 | { | ||
478 | type Chalk = chalk_ir::Canonical<T::Chalk>; | ||
479 | |||
480 | fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::Canonical<T::Chalk> { | ||
481 | let parameter = chalk_ir::CanonicalVarKind::new( | ||
482 | chalk_ir::VariableKind::Ty, | ||
483 | chalk_ir::UniverseIndex::ROOT, | ||
484 | ); | ||
485 | let value = self.value.to_chalk(db); | ||
486 | chalk_ir::Canonical { | ||
487 | value, | ||
488 | binders: chalk_ir::CanonicalVarKinds::from(&Interner, vec![parameter; self.num_vars]), | ||
489 | } | ||
490 | } | ||
491 | |||
492 | fn from_chalk(db: &dyn HirDatabase, canonical: chalk_ir::Canonical<T::Chalk>) -> Canonical<T> { | ||
493 | Canonical { | ||
494 | num_vars: canonical.binders.len(&Interner), | ||
495 | value: from_chalk(db, canonical.value), | ||
496 | } | ||
497 | } | ||
498 | } | ||
499 | |||
500 | impl ToChalk for Arc<TraitEnvironment> { | ||
501 | type Chalk = chalk_ir::Environment<Interner>; | ||
502 | |||
503 | fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::Environment<Interner> { | ||
504 | let mut clauses = Vec::new(); | ||
505 | for pred in &self.predicates { | ||
506 | if pred.is_error() { | ||
507 | // for env, we just ignore errors | ||
508 | continue; | ||
509 | } | ||
510 | let program_clause: chalk_ir::ProgramClause<Interner> = | ||
511 | pred.clone().to_chalk(db).cast(&Interner); | ||
512 | clauses.push(program_clause.into_from_env_clause(&Interner)); | ||
513 | } | ||
514 | chalk_ir::Environment::new(&Interner).add_clauses(&Interner, clauses) | ||
515 | } | ||
516 | |||
517 | fn from_chalk( | ||
518 | _db: &dyn HirDatabase, | ||
519 | _env: chalk_ir::Environment<Interner>, | ||
520 | ) -> Arc<TraitEnvironment> { | ||
521 | unimplemented!() | ||
522 | } | ||
523 | } | ||
524 | |||
525 | impl<T: ToChalk> ToChalk for InEnvironment<T> | ||
526 | where | ||
527 | T::Chalk: chalk_ir::interner::HasInterner<Interner = Interner>, | ||
528 | { | ||
529 | type Chalk = chalk_ir::InEnvironment<T::Chalk>; | ||
530 | |||
531 | fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::InEnvironment<T::Chalk> { | ||
532 | chalk_ir::InEnvironment { | ||
533 | environment: self.environment.to_chalk(db), | ||
534 | goal: self.value.to_chalk(db), | ||
535 | } | ||
536 | } | ||
537 | |||
538 | fn from_chalk( | ||
539 | db: &dyn HirDatabase, | ||
540 | in_env: chalk_ir::InEnvironment<T::Chalk>, | ||
541 | ) -> InEnvironment<T> { | ||
542 | InEnvironment { | ||
543 | environment: from_chalk(db, in_env.environment), | ||
544 | value: from_chalk(db, in_env.goal), | ||
545 | } | ||
546 | } | ||
547 | } | ||
548 | |||
549 | impl ToChalk for builtin::BuiltinImplData { | ||
550 | type Chalk = ImplDatum; | ||
551 | |||
552 | fn to_chalk(self, db: &dyn HirDatabase) -> ImplDatum { | ||
553 | let impl_type = chalk_rust_ir::ImplType::External; | ||
554 | let where_clauses = self.where_clauses.into_iter().map(|w| w.to_chalk(db)).collect(); | ||
555 | |||
556 | let impl_datum_bound = | ||
557 | chalk_rust_ir::ImplDatumBound { trait_ref: self.trait_ref.to_chalk(db), where_clauses }; | ||
558 | let associated_ty_value_ids = | ||
559 | self.assoc_ty_values.into_iter().map(|v| v.to_chalk(db)).collect(); | ||
560 | chalk_rust_ir::ImplDatum { | ||
561 | binders: make_binders(impl_datum_bound, self.num_vars), | ||
562 | impl_type, | ||
563 | polarity: chalk_rust_ir::Polarity::Positive, | ||
564 | associated_ty_value_ids, | ||
565 | } | ||
566 | } | ||
567 | |||
568 | fn from_chalk(_db: &dyn HirDatabase, _data: ImplDatum) -> Self { | ||
569 | unimplemented!() | ||
570 | } | ||
571 | } | ||
572 | |||
573 | impl ToChalk for builtin::BuiltinImplAssocTyValueData { | ||
574 | type Chalk = AssociatedTyValue; | ||
575 | |||
576 | fn to_chalk(self, db: &dyn HirDatabase) -> AssociatedTyValue { | ||
577 | let ty = self.value.to_chalk(db); | ||
578 | let value_bound = chalk_rust_ir::AssociatedTyValueBound { ty }; | ||
579 | |||
580 | chalk_rust_ir::AssociatedTyValue { | ||
581 | associated_ty_id: self.assoc_ty_id.to_chalk(db), | ||
582 | impl_id: self.impl_.to_chalk(db), | ||
583 | value: make_binders(value_bound, self.num_vars), | ||
584 | } | ||
585 | } | ||
586 | |||
587 | fn from_chalk( | ||
588 | _db: &dyn HirDatabase, | ||
589 | _data: AssociatedTyValue, | ||
590 | ) -> builtin::BuiltinImplAssocTyValueData { | ||
591 | unimplemented!() | ||
592 | } | ||
593 | } | ||
594 | |||
595 | pub(super) fn make_binders<T>(value: T, num_vars: usize) -> chalk_ir::Binders<T> | ||
596 | where | ||
597 | T: HasInterner<Interner = Interner>, | ||
598 | { | ||
599 | chalk_ir::Binders::new( | ||
600 | chalk_ir::VariableKinds::from( | ||
601 | &Interner, | ||
602 | std::iter::repeat(chalk_ir::VariableKind::Ty).take(num_vars), | ||
603 | ), | ||
604 | value, | ||
605 | ) | ||
606 | } | ||
607 | |||
608 | pub(super) fn convert_where_clauses( | ||
609 | db: &dyn HirDatabase, | ||
610 | def: GenericDefId, | ||
611 | substs: &Substs, | ||
612 | ) -> Vec<chalk_ir::QuantifiedWhereClause<Interner>> { | ||
613 | let generic_predicates = db.generic_predicates(def); | ||
614 | let mut result = Vec::with_capacity(generic_predicates.len()); | ||
615 | for pred in generic_predicates.iter() { | ||
616 | if pred.value.is_error() { | ||
617 | // skip errored predicates completely | ||
618 | continue; | ||
619 | } | ||
620 | result.push(pred.clone().subst(substs).to_chalk(db)); | ||
621 | } | ||
622 | result | ||
623 | } | ||
624 | |||
625 | pub(super) fn generic_predicate_to_inline_bound( | ||
626 | db: &dyn HirDatabase, | ||
627 | pred: &GenericPredicate, | ||
628 | self_ty: &Ty, | ||
629 | ) -> Option<chalk_rust_ir::InlineBound<Interner>> { | ||
630 | // An InlineBound is like a GenericPredicate, except the self type is left out. | ||
631 | // We don't have a special type for this, but Chalk does. | ||
632 | match pred { | ||
633 | GenericPredicate::Implemented(trait_ref) => { | ||
634 | if &trait_ref.substs[0] != self_ty { | ||
635 | // we can only convert predicates back to type bounds if they | ||
636 | // have the expected self type | ||
637 | return None; | ||
638 | } | ||
639 | let args_no_self = trait_ref.substs[1..] | ||
640 | .iter() | ||
641 | .map(|ty| ty.clone().to_chalk(db).cast(&Interner)) | ||
642 | .collect(); | ||
643 | let trait_bound = | ||
644 | chalk_rust_ir::TraitBound { trait_id: trait_ref.trait_.to_chalk(db), args_no_self }; | ||
645 | Some(chalk_rust_ir::InlineBound::TraitBound(trait_bound)) | ||
646 | } | ||
647 | GenericPredicate::Projection(proj) => { | ||
648 | if &proj.projection_ty.parameters[0] != self_ty { | ||
649 | return None; | ||
650 | } | ||
651 | let trait_ = match proj.projection_ty.associated_ty.lookup(db.upcast()).container { | ||
652 | AssocContainerId::TraitId(t) => t, | ||
653 | _ => panic!("associated type not in trait"), | ||
654 | }; | ||
655 | let args_no_self = proj.projection_ty.parameters[1..] | ||
656 | .iter() | ||
657 | .map(|ty| ty.clone().to_chalk(db).cast(&Interner)) | ||
658 | .collect(); | ||
659 | let alias_eq_bound = chalk_rust_ir::AliasEqBound { | ||
660 | value: proj.ty.clone().to_chalk(db), | ||
661 | trait_bound: chalk_rust_ir::TraitBound { | ||
662 | trait_id: trait_.to_chalk(db), | ||
663 | args_no_self, | ||
664 | }, | ||
665 | associated_ty_id: proj.projection_ty.associated_ty.to_chalk(db), | ||
666 | parameters: Vec::new(), // FIXME we don't support generic associated types yet | ||
667 | }; | ||
668 | Some(chalk_rust_ir::InlineBound::AliasEqBound(alias_eq_bound)) | ||
669 | } | ||
670 | GenericPredicate::Error => None, | ||
671 | } | ||
672 | } | ||