diff options
author | bors[bot] <26634292+bors[bot]@users.noreply.github.com> | 2021-04-06 20:11:41 +0100 |
---|---|---|
committer | GitHub <[email protected]> | 2021-04-06 20:11:41 +0100 |
commit | 1643d1534b92eef1cf55631aba3ca9289c3cea72 (patch) | |
tree | 8db339ad4a14cde9a63235d7616f648d4e560e56 /crates/hir_ty/src/traits | |
parent | 5df65e5066a534cfb1e0d5ff494b1cd775d5dd90 (diff) | |
parent | 768ee3e47a140e354575154f431421375b0b5203 (diff) |
Merge #8385
8385: Align `InferenceVar` to Chalk r=flodiebold a=flodiebold
Co-authored-by: Florian Diebold <[email protected]>
Diffstat (limited to 'crates/hir_ty/src/traits')
-rw-r--r-- | crates/hir_ty/src/traits/chalk/mapping.rs | 106 |
1 files changed, 37 insertions, 69 deletions
diff --git a/crates/hir_ty/src/traits/chalk/mapping.rs b/crates/hir_ty/src/traits/chalk/mapping.rs index cf73cb078..0536b934e 100644 --- a/crates/hir_ty/src/traits/chalk/mapping.rs +++ b/crates/hir_ty/src/traits/chalk/mapping.rs | |||
@@ -10,10 +10,9 @@ use base_db::salsa::InternKey; | |||
10 | use hir_def::{GenericDefId, TypeAliasId}; | 10 | use hir_def::{GenericDefId, TypeAliasId}; |
11 | 11 | ||
12 | use crate::{ | 12 | use crate::{ |
13 | chalk_ext::ProjectionTyExt, db::HirDatabase, dummy_usize_const, static_lifetime, AliasTy, | 13 | chalk_ext::ProjectionTyExt, db::HirDatabase, static_lifetime, AliasTy, CallableDefId, |
14 | CallableDefId, Canonical, Const, DomainGoal, FnPointer, GenericArg, InEnvironment, Lifetime, | 14 | Canonical, DomainGoal, FnPointer, GenericArg, InEnvironment, OpaqueTy, ProjectionTy, |
15 | OpaqueTy, ProjectionTy, QuantifiedWhereClause, Substitution, TraitRef, Ty, TypeWalk, | 15 | QuantifiedWhereClause, Substitution, TraitRef, Ty, TypeWalk, WhereClause, |
16 | WhereClause, | ||
17 | }; | 16 | }; |
18 | 17 | ||
19 | use super::interner::*; | 18 | use super::interner::*; |
@@ -23,16 +22,16 @@ impl ToChalk for Ty { | |||
23 | type Chalk = chalk_ir::Ty<Interner>; | 22 | type Chalk = chalk_ir::Ty<Interner>; |
24 | fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::Ty<Interner> { | 23 | fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::Ty<Interner> { |
25 | match self.into_inner() { | 24 | match self.into_inner() { |
26 | TyKind::Ref(m, lt, ty) => ref_to_chalk(db, m, lt, ty), | 25 | TyKind::Ref(m, lt, ty) => { |
27 | TyKind::Array(ty, size) => array_to_chalk(db, ty, size), | 26 | chalk_ir::TyKind::Ref(m, lt, ty.to_chalk(db)).intern(&Interner) |
28 | TyKind::Function(FnPointer { sig, substitution: substs, .. }) => { | 27 | } |
28 | TyKind::Array(ty, size) => { | ||
29 | chalk_ir::TyKind::Array(ty.to_chalk(db), size).intern(&Interner) | ||
30 | } | ||
31 | TyKind::Function(FnPointer { sig, substitution: substs, num_binders }) => { | ||
29 | let substitution = chalk_ir::FnSubst(substs.0.to_chalk(db)); | 32 | let substitution = chalk_ir::FnSubst(substs.0.to_chalk(db)); |
30 | chalk_ir::TyKind::Function(chalk_ir::FnPointer { | 33 | chalk_ir::TyKind::Function(chalk_ir::FnPointer { num_binders, sig, substitution }) |
31 | num_binders: 0, | 34 | .intern(&Interner) |
32 | sig, | ||
33 | substitution, | ||
34 | }) | ||
35 | .intern(&Interner) | ||
36 | } | 35 | } |
37 | TyKind::AssociatedType(assoc_type_id, substs) => { | 36 | TyKind::AssociatedType(assoc_type_id, substs) => { |
38 | let substitution = substs.to_chalk(db); | 37 | let substitution = substs.to_chalk(db); |
@@ -74,22 +73,13 @@ impl ToChalk for Ty { | |||
74 | chalk_ir::TyKind::Adt(adt_id, substitution).intern(&Interner) | 73 | chalk_ir::TyKind::Adt(adt_id, substitution).intern(&Interner) |
75 | } | 74 | } |
76 | TyKind::Alias(AliasTy::Projection(proj_ty)) => { | 75 | TyKind::Alias(AliasTy::Projection(proj_ty)) => { |
77 | let associated_ty_id = proj_ty.associated_ty_id; | 76 | chalk_ir::AliasTy::Projection(proj_ty.to_chalk(db)) |
78 | let substitution = proj_ty.substitution.to_chalk(db); | ||
79 | chalk_ir::AliasTy::Projection(chalk_ir::ProjectionTy { | ||
80 | associated_ty_id, | ||
81 | substitution, | ||
82 | }) | ||
83 | .cast(&Interner) | ||
84 | .intern(&Interner) | ||
85 | } | ||
86 | TyKind::Alias(AliasTy::Opaque(opaque_ty)) => { | ||
87 | let opaque_ty_id = opaque_ty.opaque_ty_id; | ||
88 | let substitution = opaque_ty.substitution.to_chalk(db); | ||
89 | chalk_ir::AliasTy::Opaque(chalk_ir::OpaqueTy { opaque_ty_id, substitution }) | ||
90 | .cast(&Interner) | 77 | .cast(&Interner) |
91 | .intern(&Interner) | 78 | .intern(&Interner) |
92 | } | 79 | } |
80 | TyKind::Alias(AliasTy::Opaque(opaque_ty)) => { | ||
81 | chalk_ir::AliasTy::Opaque(opaque_ty.to_chalk(db)).cast(&Interner).intern(&Interner) | ||
82 | } | ||
93 | TyKind::Placeholder(idx) => idx.to_ty::<Interner>(&Interner), | 83 | TyKind::Placeholder(idx) => idx.to_ty::<Interner>(&Interner), |
94 | TyKind::BoundVar(idx) => chalk_ir::TyKind::BoundVar(idx).intern(&Interner), | 84 | TyKind::BoundVar(idx) => chalk_ir::TyKind::BoundVar(idx).intern(&Interner), |
95 | TyKind::InferenceVar(..) => panic!("uncanonicalized infer ty"), | 85 | TyKind::InferenceVar(..) => panic!("uncanonicalized infer ty"), |
@@ -101,7 +91,7 @@ impl ToChalk for Ty { | |||
101 | ); | 91 | ); |
102 | let bounded_ty = chalk_ir::DynTy { | 92 | let bounded_ty = chalk_ir::DynTy { |
103 | bounds: chalk_ir::Binders::new(binders, where_clauses), | 93 | bounds: chalk_ir::Binders::new(binders, where_clauses), |
104 | lifetime: static_lifetime(), | 94 | lifetime: dyn_ty.lifetime, |
105 | }; | 95 | }; |
106 | chalk_ir::TyKind::Dyn(bounded_ty).intern(&Interner) | 96 | chalk_ir::TyKind::Dyn(bounded_ty).intern(&Interner) |
107 | } | 97 | } |
@@ -114,17 +104,10 @@ impl ToChalk for Ty { | |||
114 | chalk_ir::TyKind::Array(ty, size) => TyKind::Array(from_chalk(db, ty), size), | 104 | chalk_ir::TyKind::Array(ty, size) => TyKind::Array(from_chalk(db, ty), size), |
115 | chalk_ir::TyKind::Placeholder(idx) => TyKind::Placeholder(idx), | 105 | chalk_ir::TyKind::Placeholder(idx) => TyKind::Placeholder(idx), |
116 | chalk_ir::TyKind::Alias(chalk_ir::AliasTy::Projection(proj)) => { | 106 | chalk_ir::TyKind::Alias(chalk_ir::AliasTy::Projection(proj)) => { |
117 | let associated_ty = proj.associated_ty_id; | 107 | TyKind::Alias(AliasTy::Projection(from_chalk(db, proj))) |
118 | let parameters = from_chalk(db, proj.substitution); | ||
119 | TyKind::Alias(AliasTy::Projection(ProjectionTy { | ||
120 | associated_ty_id: associated_ty, | ||
121 | substitution: parameters, | ||
122 | })) | ||
123 | } | 108 | } |
124 | chalk_ir::TyKind::Alias(chalk_ir::AliasTy::Opaque(opaque_ty)) => { | 109 | chalk_ir::TyKind::Alias(chalk_ir::AliasTy::Opaque(opaque_ty)) => { |
125 | let opaque_ty_id = opaque_ty.opaque_ty_id; | 110 | TyKind::Alias(AliasTy::Opaque(from_chalk(db, opaque_ty))) |
126 | let parameters = from_chalk(db, opaque_ty.substitution); | ||
127 | TyKind::Alias(AliasTy::Opaque(OpaqueTy { opaque_ty_id, substitution: parameters })) | ||
128 | } | 111 | } |
129 | chalk_ir::TyKind::Function(chalk_ir::FnPointer { | 112 | chalk_ir::TyKind::Function(chalk_ir::FnPointer { |
130 | num_binders, | 113 | num_binders, |
@@ -138,18 +121,19 @@ impl ToChalk for Ty { | |||
138 | } | 121 | } |
139 | chalk_ir::TyKind::BoundVar(idx) => TyKind::BoundVar(idx), | 122 | chalk_ir::TyKind::BoundVar(idx) => TyKind::BoundVar(idx), |
140 | chalk_ir::TyKind::InferenceVar(_iv, _kind) => TyKind::Error, | 123 | chalk_ir::TyKind::InferenceVar(_iv, _kind) => TyKind::Error, |
141 | chalk_ir::TyKind::Dyn(where_clauses) => { | 124 | chalk_ir::TyKind::Dyn(dyn_ty) => { |
142 | assert_eq!(where_clauses.bounds.binders.len(&Interner), 1); | 125 | assert_eq!(dyn_ty.bounds.binders.len(&Interner), 1); |
143 | let bounds = where_clauses | 126 | let (bounds, binders) = dyn_ty.bounds.into_value_and_skipped_binders(); |
144 | .bounds | 127 | let where_clauses = crate::QuantifiedWhereClauses::from_iter( |
145 | .skip_binders() | 128 | &Interner, |
146 | .iter(&Interner) | 129 | bounds.interned().iter().cloned().map(|p| from_chalk(db, p)), |
147 | .map(|c| from_chalk(db, c.clone())); | 130 | ); |
148 | TyKind::Dyn(crate::DynTy { | 131 | TyKind::Dyn(crate::DynTy { |
149 | bounds: crate::Binders::new( | 132 | bounds: crate::Binders::new(binders, where_clauses), |
150 | where_clauses.bounds.binders.clone(), | 133 | // HACK: we sometimes get lifetime variables back in solutions |
151 | crate::QuantifiedWhereClauses::from_iter(&Interner, bounds), | 134 | // from Chalk, and don't have the infrastructure to substitute |
152 | ), | 135 | // them yet. So for now we just turn them into 'static right |
136 | // when we get them | ||
153 | lifetime: static_lifetime(), | 137 | lifetime: static_lifetime(), |
154 | }) | 138 | }) |
155 | } | 139 | } |
@@ -169,8 +153,12 @@ impl ToChalk for Ty { | |||
169 | } | 153 | } |
170 | chalk_ir::TyKind::Raw(mutability, ty) => TyKind::Raw(mutability, from_chalk(db, ty)), | 154 | chalk_ir::TyKind::Raw(mutability, ty) => TyKind::Raw(mutability, from_chalk(db, ty)), |
171 | chalk_ir::TyKind::Slice(ty) => TyKind::Slice(from_chalk(db, ty)), | 155 | chalk_ir::TyKind::Slice(ty) => TyKind::Slice(from_chalk(db, ty)), |
172 | chalk_ir::TyKind::Ref(mutability, lifetime, ty) => { | 156 | chalk_ir::TyKind::Ref(mutability, _lifetime, ty) => { |
173 | TyKind::Ref(mutability, lifetime, from_chalk(db, ty)) | 157 | // HACK: we sometimes get lifetime variables back in solutions |
158 | // from Chalk, and don't have the infrastructure to substitute | ||
159 | // them yet. So for now we just turn them into 'static right | ||
160 | // when we get them | ||
161 | TyKind::Ref(mutability, static_lifetime(), from_chalk(db, ty)) | ||
174 | } | 162 | } |
175 | chalk_ir::TyKind::Str => TyKind::Str, | 163 | chalk_ir::TyKind::Str => TyKind::Str, |
176 | chalk_ir::TyKind::Never => TyKind::Never, | 164 | chalk_ir::TyKind::Never => TyKind::Never, |
@@ -189,26 +177,6 @@ impl ToChalk for Ty { | |||
189 | } | 177 | } |
190 | } | 178 | } |
191 | 179 | ||
192 | /// We currently don't model lifetimes, but Chalk does. So, we have to insert a | ||
193 | /// fake lifetime here, because Chalks built-in logic may expect it to be there. | ||
194 | fn ref_to_chalk( | ||
195 | db: &dyn HirDatabase, | ||
196 | mutability: chalk_ir::Mutability, | ||
197 | _lifetime: Lifetime, | ||
198 | ty: Ty, | ||
199 | ) -> chalk_ir::Ty<Interner> { | ||
200 | let arg = ty.to_chalk(db); | ||
201 | let lifetime = static_lifetime(); | ||
202 | chalk_ir::TyKind::Ref(mutability, lifetime, arg).intern(&Interner) | ||
203 | } | ||
204 | |||
205 | /// We currently don't model constants, but Chalk does. So, we have to insert a | ||
206 | /// fake constant here, because Chalks built-in logic may expect it to be there. | ||
207 | fn array_to_chalk(db: &dyn HirDatabase, ty: Ty, _: Const) -> chalk_ir::Ty<Interner> { | ||
208 | let arg = ty.to_chalk(db); | ||
209 | chalk_ir::TyKind::Array(arg, dummy_usize_const()).intern(&Interner) | ||
210 | } | ||
211 | |||
212 | impl ToChalk for GenericArg { | 180 | impl ToChalk for GenericArg { |
213 | type Chalk = chalk_ir::GenericArg<Interner>; | 181 | type Chalk = chalk_ir::GenericArg<Interner>; |
214 | 182 | ||