diff options
Diffstat (limited to 'crates/hir_ty/src/lower.rs')
-rw-r--r-- | crates/hir_ty/src/lower.rs | 710 |
1 files changed, 362 insertions, 348 deletions
diff --git a/crates/hir_ty/src/lower.rs b/crates/hir_ty/src/lower.rs index 5fa83567b..d026310f4 100644 --- a/crates/hir_ty/src/lower.rs +++ b/crates/hir_ty/src/lower.rs | |||
@@ -8,7 +8,7 @@ | |||
8 | use std::{iter, sync::Arc}; | 8 | use std::{iter, sync::Arc}; |
9 | 9 | ||
10 | use base_db::CrateId; | 10 | use base_db::CrateId; |
11 | use chalk_ir::Mutability; | 11 | use chalk_ir::{cast::Cast, Mutability, Safety}; |
12 | use hir_def::{ | 12 | use hir_def::{ |
13 | adt::StructKind, | 13 | adt::StructKind, |
14 | builtin_type::BuiltinType, | 14 | builtin_type::BuiltinType, |
@@ -27,13 +27,15 @@ use stdx::impl_from; | |||
27 | 27 | ||
28 | use crate::{ | 28 | use crate::{ |
29 | db::HirDatabase, | 29 | db::HirDatabase, |
30 | to_assoc_type_id, to_placeholder_idx, | ||
31 | traits::chalk::{Interner, ToChalk}, | ||
30 | utils::{ | 32 | utils::{ |
31 | all_super_trait_refs, associated_type_by_name_including_super_traits, generics, | 33 | all_super_trait_refs, associated_type_by_name_including_super_traits, generics, |
32 | make_mut_slice, variant_data, | 34 | make_mut_slice, variant_data, |
33 | }, | 35 | }, |
34 | AliasTy, Binders, BoundVar, CallableSig, DebruijnIndex, FnPointer, FnSig, GenericPredicate, | 36 | AliasTy, Binders, BoundVar, CallableSig, DebruijnIndex, FnPointer, FnSig, GenericPredicate, |
35 | OpaqueTy, OpaqueTyId, PolyFnSig, ProjectionPredicate, ProjectionTy, ReturnTypeImplTrait, | 37 | ImplTraitId, OpaqueTy, PolyFnSig, ProjectionPredicate, ProjectionTy, ReturnTypeImplTrait, |
36 | ReturnTypeImplTraits, Substs, TraitEnvironment, TraitRef, Ty, TypeWalk, | 38 | ReturnTypeImplTraits, Substs, TraitEnvironment, TraitRef, Ty, TyKind, TypeWalk, |
37 | }; | 39 | }; |
38 | 40 | ||
39 | #[derive(Debug)] | 41 | #[derive(Debug)] |
@@ -138,69 +140,71 @@ pub enum TypeParamLoweringMode { | |||
138 | Variable, | 140 | Variable, |
139 | } | 141 | } |
140 | 142 | ||
141 | impl Ty { | 143 | impl<'a> TyLoweringContext<'a> { |
142 | pub fn from_hir(ctx: &TyLoweringContext<'_>, type_ref: &TypeRef) -> Self { | 144 | pub fn lower_ty(&self, type_ref: &TypeRef) -> Ty { |
143 | Ty::from_hir_ext(ctx, type_ref).0 | 145 | self.lower_ty_ext(type_ref).0 |
144 | } | 146 | } |
145 | pub fn from_hir_ext(ctx: &TyLoweringContext<'_>, type_ref: &TypeRef) -> (Self, Option<TypeNs>) { | 147 | |
148 | fn lower_ty_ext(&self, type_ref: &TypeRef) -> (Ty, Option<TypeNs>) { | ||
146 | let mut res = None; | 149 | let mut res = None; |
147 | let ty = match type_ref { | 150 | let ty = match type_ref { |
148 | TypeRef::Never => Ty::Never, | 151 | TypeRef::Never => TyKind::Never.intern(&Interner), |
149 | TypeRef::Tuple(inner) => { | 152 | TypeRef::Tuple(inner) => { |
150 | let inner_tys: Arc<[Ty]> = inner.iter().map(|tr| Ty::from_hir(ctx, tr)).collect(); | 153 | let inner_tys: Arc<[Ty]> = inner.iter().map(|tr| self.lower_ty(tr)).collect(); |
151 | Ty::Tuple(inner_tys.len(), Substs(inner_tys)) | 154 | TyKind::Tuple(inner_tys.len(), Substs(inner_tys)).intern(&Interner) |
152 | } | 155 | } |
153 | TypeRef::Path(path) => { | 156 | TypeRef::Path(path) => { |
154 | let (ty, res_) = Ty::from_hir_path(ctx, path); | 157 | let (ty, res_) = self.lower_path(path); |
155 | res = res_; | 158 | res = res_; |
156 | ty | 159 | ty |
157 | } | 160 | } |
158 | TypeRef::RawPtr(inner, mutability) => { | 161 | TypeRef::RawPtr(inner, mutability) => { |
159 | let inner_ty = Ty::from_hir(ctx, inner); | 162 | let inner_ty = self.lower_ty(inner); |
160 | Ty::Raw(lower_to_chalk_mutability(*mutability), Substs::single(inner_ty)) | 163 | TyKind::Raw(lower_to_chalk_mutability(*mutability), Substs::single(inner_ty)) |
164 | .intern(&Interner) | ||
161 | } | 165 | } |
162 | TypeRef::Array(inner) => { | 166 | TypeRef::Array(inner) => { |
163 | let inner_ty = Ty::from_hir(ctx, inner); | 167 | let inner_ty = self.lower_ty(inner); |
164 | Ty::Array(Substs::single(inner_ty)) | 168 | TyKind::Array(Substs::single(inner_ty)).intern(&Interner) |
165 | } | 169 | } |
166 | TypeRef::Slice(inner) => { | 170 | TypeRef::Slice(inner) => { |
167 | let inner_ty = Ty::from_hir(ctx, inner); | 171 | let inner_ty = self.lower_ty(inner); |
168 | Ty::Slice(Substs::single(inner_ty)) | 172 | TyKind::Slice(Substs::single(inner_ty)).intern(&Interner) |
169 | } | 173 | } |
170 | TypeRef::Reference(inner, _, mutability) => { | 174 | TypeRef::Reference(inner, _, mutability) => { |
171 | let inner_ty = Ty::from_hir(ctx, inner); | 175 | let inner_ty = self.lower_ty(inner); |
172 | Ty::Ref(lower_to_chalk_mutability(*mutability), Substs::single(inner_ty)) | 176 | TyKind::Ref(lower_to_chalk_mutability(*mutability), Substs::single(inner_ty)) |
177 | .intern(&Interner) | ||
173 | } | 178 | } |
174 | TypeRef::Placeholder => Ty::Unknown, | 179 | TypeRef::Placeholder => TyKind::Unknown.intern(&Interner), |
175 | TypeRef::Fn(params, is_varargs) => { | 180 | TypeRef::Fn(params, is_varargs) => { |
176 | let substs = Substs(params.iter().map(|tr| Ty::from_hir(ctx, tr)).collect()); | 181 | let substs = Substs(params.iter().map(|tr| self.lower_ty(tr)).collect()); |
177 | Ty::Function(FnPointer { | 182 | TyKind::Function(FnPointer { |
178 | num_args: substs.len() - 1, | 183 | num_args: substs.len() - 1, |
179 | sig: FnSig { variadic: *is_varargs }, | 184 | sig: FnSig { abi: (), safety: Safety::Safe, variadic: *is_varargs }, |
180 | substs, | 185 | substs, |
181 | }) | 186 | }) |
187 | .intern(&Interner) | ||
182 | } | 188 | } |
183 | TypeRef::DynTrait(bounds) => { | 189 | TypeRef::DynTrait(bounds) => { |
184 | let self_ty = Ty::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0)); | 190 | let self_ty = |
185 | let predicates = ctx.with_shifted_in(DebruijnIndex::ONE, |ctx| { | 191 | TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0)).intern(&Interner); |
186 | bounds | 192 | let predicates = self.with_shifted_in(DebruijnIndex::ONE, |ctx| { |
187 | .iter() | 193 | bounds.iter().flat_map(|b| ctx.lower_type_bound(b, self_ty.clone())).collect() |
188 | .flat_map(|b| GenericPredicate::from_type_bound(ctx, b, self_ty.clone())) | ||
189 | .collect() | ||
190 | }); | 194 | }); |
191 | Ty::Dyn(predicates) | 195 | TyKind::Dyn(predicates).intern(&Interner) |
192 | } | 196 | } |
193 | TypeRef::ImplTrait(bounds) => { | 197 | TypeRef::ImplTrait(bounds) => { |
194 | match ctx.impl_trait_mode { | 198 | match self.impl_trait_mode { |
195 | ImplTraitLoweringMode::Opaque => { | 199 | ImplTraitLoweringMode::Opaque => { |
196 | let idx = ctx.impl_trait_counter.get(); | 200 | let idx = self.impl_trait_counter.get(); |
197 | ctx.impl_trait_counter.set(idx + 1); | 201 | self.impl_trait_counter.set(idx + 1); |
198 | 202 | ||
199 | assert!(idx as usize == ctx.opaque_type_data.borrow().len()); | 203 | assert!(idx as usize == self.opaque_type_data.borrow().len()); |
200 | // this dance is to make sure the data is in the right | 204 | // this dance is to make sure the data is in the right |
201 | // place even if we encounter more opaque types while | 205 | // place even if we encounter more opaque types while |
202 | // lowering the bounds | 206 | // lowering the bounds |
203 | ctx.opaque_type_data | 207 | self.opaque_type_data |
204 | .borrow_mut() | 208 | .borrow_mut() |
205 | .push(ReturnTypeImplTrait { bounds: Binders::new(1, Vec::new()) }); | 209 | .push(ReturnTypeImplTrait { bounds: Binders::new(1, Vec::new()) }); |
206 | // We don't want to lower the bounds inside the binders | 210 | // We don't want to lower the bounds inside the binders |
@@ -212,65 +216,70 @@ impl Ty { | |||
212 | // other, but separately. So if the `T` refers to a type | 216 | // other, but separately. So if the `T` refers to a type |
213 | // parameter of the outer function, it's just one binder | 217 | // parameter of the outer function, it's just one binder |
214 | // away instead of two. | 218 | // away instead of two. |
215 | let actual_opaque_type_data = ctx | 219 | let actual_opaque_type_data = self |
216 | .with_debruijn(DebruijnIndex::INNERMOST, |ctx| { | 220 | .with_debruijn(DebruijnIndex::INNERMOST, |ctx| { |
217 | ReturnTypeImplTrait::from_hir(ctx, &bounds) | 221 | ctx.lower_impl_trait(&bounds) |
218 | }); | 222 | }); |
219 | ctx.opaque_type_data.borrow_mut()[idx as usize] = actual_opaque_type_data; | 223 | self.opaque_type_data.borrow_mut()[idx as usize] = actual_opaque_type_data; |
220 | 224 | ||
221 | let func = match ctx.resolver.generic_def() { | 225 | let func = match self.resolver.generic_def() { |
222 | Some(GenericDefId::FunctionId(f)) => f, | 226 | Some(GenericDefId::FunctionId(f)) => f, |
223 | _ => panic!("opaque impl trait lowering in non-function"), | 227 | _ => panic!("opaque impl trait lowering in non-function"), |
224 | }; | 228 | }; |
225 | let impl_trait_id = OpaqueTyId::ReturnTypeImplTrait(func, idx); | 229 | let impl_trait_id = ImplTraitId::ReturnTypeImplTrait(func, idx); |
226 | let generics = generics(ctx.db.upcast(), func.into()); | 230 | let opaque_ty_id = self.db.intern_impl_trait_id(impl_trait_id).into(); |
227 | let parameters = Substs::bound_vars(&generics, ctx.in_binders); | 231 | let generics = generics(self.db.upcast(), func.into()); |
228 | Ty::Alias(AliasTy::Opaque(OpaqueTy { | 232 | let parameters = Substs::bound_vars(&generics, self.in_binders); |
229 | opaque_ty_id: impl_trait_id, | 233 | TyKind::Alias(AliasTy::Opaque(OpaqueTy { |
230 | parameters, | 234 | opaque_ty_id, |
235 | substitution: parameters, | ||
231 | })) | 236 | })) |
237 | .intern(&Interner) | ||
232 | } | 238 | } |
233 | ImplTraitLoweringMode::Param => { | 239 | ImplTraitLoweringMode::Param => { |
234 | let idx = ctx.impl_trait_counter.get(); | 240 | let idx = self.impl_trait_counter.get(); |
235 | // FIXME we're probably doing something wrong here | 241 | // FIXME we're probably doing something wrong here |
236 | ctx.impl_trait_counter.set(idx + count_impl_traits(type_ref) as u16); | 242 | self.impl_trait_counter.set(idx + count_impl_traits(type_ref) as u16); |
237 | if let Some(def) = ctx.resolver.generic_def() { | 243 | if let Some(def) = self.resolver.generic_def() { |
238 | let generics = generics(ctx.db.upcast(), def); | 244 | let generics = generics(self.db.upcast(), def); |
239 | let param = generics | 245 | let param = generics |
240 | .iter() | 246 | .iter() |
241 | .filter(|(_, data)| { | 247 | .filter(|(_, data)| { |
242 | data.provenance == TypeParamProvenance::ArgumentImplTrait | 248 | data.provenance == TypeParamProvenance::ArgumentImplTrait |
243 | }) | 249 | }) |
244 | .nth(idx as usize) | 250 | .nth(idx as usize) |
245 | .map_or(Ty::Unknown, |(id, _)| Ty::Placeholder(id)); | 251 | .map_or(TyKind::Unknown, |(id, _)| { |
246 | param | 252 | TyKind::Placeholder(to_placeholder_idx(self.db, id)) |
253 | }); | ||
254 | param.intern(&Interner) | ||
247 | } else { | 255 | } else { |
248 | Ty::Unknown | 256 | TyKind::Unknown.intern(&Interner) |
249 | } | 257 | } |
250 | } | 258 | } |
251 | ImplTraitLoweringMode::Variable => { | 259 | ImplTraitLoweringMode::Variable => { |
252 | let idx = ctx.impl_trait_counter.get(); | 260 | let idx = self.impl_trait_counter.get(); |
253 | // FIXME we're probably doing something wrong here | 261 | // FIXME we're probably doing something wrong here |
254 | ctx.impl_trait_counter.set(idx + count_impl_traits(type_ref) as u16); | 262 | self.impl_trait_counter.set(idx + count_impl_traits(type_ref) as u16); |
255 | let (parent_params, self_params, list_params, _impl_trait_params) = | 263 | let (parent_params, self_params, list_params, _impl_trait_params) = |
256 | if let Some(def) = ctx.resolver.generic_def() { | 264 | if let Some(def) = self.resolver.generic_def() { |
257 | let generics = generics(ctx.db.upcast(), def); | 265 | let generics = generics(self.db.upcast(), def); |
258 | generics.provenance_split() | 266 | generics.provenance_split() |
259 | } else { | 267 | } else { |
260 | (0, 0, 0, 0) | 268 | (0, 0, 0, 0) |
261 | }; | 269 | }; |
262 | Ty::BoundVar(BoundVar::new( | 270 | TyKind::BoundVar(BoundVar::new( |
263 | ctx.in_binders, | 271 | self.in_binders, |
264 | idx as usize + parent_params + self_params + list_params, | 272 | idx as usize + parent_params + self_params + list_params, |
265 | )) | 273 | )) |
274 | .intern(&Interner) | ||
266 | } | 275 | } |
267 | ImplTraitLoweringMode::Disallowed => { | 276 | ImplTraitLoweringMode::Disallowed => { |
268 | // FIXME: report error | 277 | // FIXME: report error |
269 | Ty::Unknown | 278 | TyKind::Unknown.intern(&Interner) |
270 | } | 279 | } |
271 | } | 280 | } |
272 | } | 281 | } |
273 | TypeRef::Error => Ty::Unknown, | 282 | TypeRef::Error => TyKind::Unknown.intern(&Interner), |
274 | }; | 283 | }; |
275 | (ty, res) | 284 | (ty, res) |
276 | } | 285 | } |
@@ -278,7 +287,7 @@ impl Ty { | |||
278 | /// This is only for `generic_predicates_for_param`, where we can't just | 287 | /// This is only for `generic_predicates_for_param`, where we can't just |
279 | /// lower the self types of the predicates since that could lead to cycles. | 288 | /// lower the self types of the predicates since that could lead to cycles. |
280 | /// So we just check here if the `type_ref` resolves to a generic param, and which. | 289 | /// So we just check here if the `type_ref` resolves to a generic param, and which. |
281 | fn from_hir_only_param(ctx: &TyLoweringContext<'_>, type_ref: &TypeRef) -> Option<TypeParamId> { | 290 | fn lower_ty_only_param(&self, type_ref: &TypeRef) -> Option<TypeParamId> { |
282 | let path = match type_ref { | 291 | let path = match type_ref { |
283 | TypeRef::Path(path) => path, | 292 | TypeRef::Path(path) => path, |
284 | _ => return None, | 293 | _ => return None, |
@@ -290,7 +299,7 @@ impl Ty { | |||
290 | return None; | 299 | return None; |
291 | } | 300 | } |
292 | let resolution = | 301 | let resolution = |
293 | match ctx.resolver.resolve_path_in_type_ns(ctx.db.upcast(), path.mod_path()) { | 302 | match self.resolver.resolve_path_in_type_ns(self.db.upcast(), path.mod_path()) { |
294 | Some((it, None)) => it, | 303 | Some((it, None)) => it, |
295 | _ => return None, | 304 | _ => return None, |
296 | }; | 305 | }; |
@@ -301,8 +310,8 @@ impl Ty { | |||
301 | } | 310 | } |
302 | } | 311 | } |
303 | 312 | ||
304 | pub(crate) fn from_type_relative_path( | 313 | pub(crate) fn lower_ty_relative_path( |
305 | ctx: &TyLoweringContext<'_>, | 314 | &self, |
306 | ty: Ty, | 315 | ty: Ty, |
307 | // We need the original resolution to lower `Self::AssocTy` correctly | 316 | // We need the original resolution to lower `Self::AssocTy` correctly |
308 | res: Option<TypeNs>, | 317 | res: Option<TypeNs>, |
@@ -311,17 +320,17 @@ impl Ty { | |||
311 | if remaining_segments.len() == 1 { | 320 | if remaining_segments.len() == 1 { |
312 | // resolve unselected assoc types | 321 | // resolve unselected assoc types |
313 | let segment = remaining_segments.first().unwrap(); | 322 | let segment = remaining_segments.first().unwrap(); |
314 | (Ty::select_associated_type(ctx, res, segment), None) | 323 | (self.select_associated_type(res, segment), None) |
315 | } else if remaining_segments.len() > 1 { | 324 | } else if remaining_segments.len() > 1 { |
316 | // FIXME report error (ambiguous associated type) | 325 | // FIXME report error (ambiguous associated type) |
317 | (Ty::Unknown, None) | 326 | (TyKind::Unknown.intern(&Interner), None) |
318 | } else { | 327 | } else { |
319 | (ty, res) | 328 | (ty, res) |
320 | } | 329 | } |
321 | } | 330 | } |
322 | 331 | ||
323 | pub(crate) fn from_partly_resolved_hir_path( | 332 | pub(crate) fn lower_partly_resolved_path( |
324 | ctx: &TyLoweringContext<'_>, | 333 | &self, |
325 | resolution: TypeNs, | 334 | resolution: TypeNs, |
326 | resolved_segment: PathSegment<'_>, | 335 | resolved_segment: PathSegment<'_>, |
327 | remaining_segments: PathSegments<'_>, | 336 | remaining_segments: PathSegments<'_>, |
@@ -331,103 +340,109 @@ impl Ty { | |||
331 | TypeNs::TraitId(trait_) => { | 340 | TypeNs::TraitId(trait_) => { |
332 | // if this is a bare dyn Trait, we'll directly put the required ^0 for the self type in there | 341 | // if this is a bare dyn Trait, we'll directly put the required ^0 for the self type in there |
333 | let self_ty = if remaining_segments.len() == 0 { | 342 | let self_ty = if remaining_segments.len() == 0 { |
334 | Some(Ty::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0))) | 343 | Some( |
344 | TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0)) | ||
345 | .intern(&Interner), | ||
346 | ) | ||
335 | } else { | 347 | } else { |
336 | None | 348 | None |
337 | }; | 349 | }; |
338 | let trait_ref = | 350 | let trait_ref = |
339 | TraitRef::from_resolved_path(ctx, trait_, resolved_segment, self_ty); | 351 | self.lower_trait_ref_from_resolved_path(trait_, resolved_segment, self_ty); |
340 | let ty = if remaining_segments.len() == 1 { | 352 | let ty = if remaining_segments.len() == 1 { |
341 | let segment = remaining_segments.first().unwrap(); | 353 | let segment = remaining_segments.first().unwrap(); |
342 | let found = associated_type_by_name_including_super_traits( | 354 | let found = associated_type_by_name_including_super_traits( |
343 | ctx.db, | 355 | self.db, |
344 | trait_ref, | 356 | trait_ref, |
345 | &segment.name, | 357 | &segment.name, |
346 | ); | 358 | ); |
347 | match found { | 359 | match found { |
348 | Some((super_trait_ref, associated_ty)) => { | 360 | Some((super_trait_ref, associated_ty)) => { |
349 | // FIXME handle type parameters on the segment | 361 | // FIXME handle type parameters on the segment |
350 | Ty::Alias(AliasTy::Projection(ProjectionTy { | 362 | TyKind::Alias(AliasTy::Projection(ProjectionTy { |
351 | associated_ty, | 363 | associated_ty_id: to_assoc_type_id(associated_ty), |
352 | parameters: super_trait_ref.substs, | 364 | substitution: super_trait_ref.substs, |
353 | })) | 365 | })) |
366 | .intern(&Interner) | ||
354 | } | 367 | } |
355 | None => { | 368 | None => { |
356 | // FIXME: report error (associated type not found) | 369 | // FIXME: report error (associated type not found) |
357 | Ty::Unknown | 370 | TyKind::Unknown.intern(&Interner) |
358 | } | 371 | } |
359 | } | 372 | } |
360 | } else if remaining_segments.len() > 1 { | 373 | } else if remaining_segments.len() > 1 { |
361 | // FIXME report error (ambiguous associated type) | 374 | // FIXME report error (ambiguous associated type) |
362 | Ty::Unknown | 375 | TyKind::Unknown.intern(&Interner) |
363 | } else { | 376 | } else { |
364 | Ty::Dyn(Arc::new([GenericPredicate::Implemented(trait_ref)])) | 377 | TyKind::Dyn(Arc::new([GenericPredicate::Implemented(trait_ref)])) |
378 | .intern(&Interner) | ||
365 | }; | 379 | }; |
366 | return (ty, None); | 380 | return (ty, None); |
367 | } | 381 | } |
368 | TypeNs::GenericParam(param_id) => { | 382 | TypeNs::GenericParam(param_id) => { |
369 | let generics = generics( | 383 | let generics = generics( |
370 | ctx.db.upcast(), | 384 | self.db.upcast(), |
371 | ctx.resolver.generic_def().expect("generics in scope"), | 385 | self.resolver.generic_def().expect("generics in scope"), |
372 | ); | 386 | ); |
373 | match ctx.type_param_mode { | 387 | match self.type_param_mode { |
374 | TypeParamLoweringMode::Placeholder => Ty::Placeholder(param_id), | 388 | TypeParamLoweringMode::Placeholder => { |
389 | TyKind::Placeholder(to_placeholder_idx(self.db, param_id)) | ||
390 | } | ||
375 | TypeParamLoweringMode::Variable => { | 391 | TypeParamLoweringMode::Variable => { |
376 | let idx = generics.param_idx(param_id).expect("matching generics"); | 392 | let idx = generics.param_idx(param_id).expect("matching generics"); |
377 | Ty::BoundVar(BoundVar::new(ctx.in_binders, idx)) | 393 | TyKind::BoundVar(BoundVar::new(self.in_binders, idx)) |
378 | } | 394 | } |
379 | } | 395 | } |
396 | .intern(&Interner) | ||
380 | } | 397 | } |
381 | TypeNs::SelfType(impl_id) => { | 398 | TypeNs::SelfType(impl_id) => { |
382 | let generics = generics(ctx.db.upcast(), impl_id.into()); | 399 | let generics = generics(self.db.upcast(), impl_id.into()); |
383 | let substs = match ctx.type_param_mode { | 400 | let substs = match self.type_param_mode { |
384 | TypeParamLoweringMode::Placeholder => { | 401 | TypeParamLoweringMode::Placeholder => { |
385 | Substs::type_params_for_generics(&generics) | 402 | Substs::type_params_for_generics(self.db, &generics) |
386 | } | 403 | } |
387 | TypeParamLoweringMode::Variable => { | 404 | TypeParamLoweringMode::Variable => { |
388 | Substs::bound_vars(&generics, ctx.in_binders) | 405 | Substs::bound_vars(&generics, self.in_binders) |
389 | } | 406 | } |
390 | }; | 407 | }; |
391 | ctx.db.impl_self_ty(impl_id).subst(&substs) | 408 | self.db.impl_self_ty(impl_id).subst(&substs) |
392 | } | 409 | } |
393 | TypeNs::AdtSelfType(adt) => { | 410 | TypeNs::AdtSelfType(adt) => { |
394 | let generics = generics(ctx.db.upcast(), adt.into()); | 411 | let generics = generics(self.db.upcast(), adt.into()); |
395 | let substs = match ctx.type_param_mode { | 412 | let substs = match self.type_param_mode { |
396 | TypeParamLoweringMode::Placeholder => { | 413 | TypeParamLoweringMode::Placeholder => { |
397 | Substs::type_params_for_generics(&generics) | 414 | Substs::type_params_for_generics(self.db, &generics) |
398 | } | 415 | } |
399 | TypeParamLoweringMode::Variable => { | 416 | TypeParamLoweringMode::Variable => { |
400 | Substs::bound_vars(&generics, ctx.in_binders) | 417 | Substs::bound_vars(&generics, self.in_binders) |
401 | } | 418 | } |
402 | }; | 419 | }; |
403 | ctx.db.ty(adt.into()).subst(&substs) | 420 | self.db.ty(adt.into()).subst(&substs) |
404 | } | 421 | } |
405 | 422 | ||
406 | TypeNs::AdtId(it) => { | 423 | TypeNs::AdtId(it) => self.lower_path_inner(resolved_segment, it.into(), infer_args), |
407 | Ty::from_hir_path_inner(ctx, resolved_segment, it.into(), infer_args) | ||
408 | } | ||
409 | TypeNs::BuiltinType(it) => { | 424 | TypeNs::BuiltinType(it) => { |
410 | Ty::from_hir_path_inner(ctx, resolved_segment, it.into(), infer_args) | 425 | self.lower_path_inner(resolved_segment, it.into(), infer_args) |
411 | } | 426 | } |
412 | TypeNs::TypeAliasId(it) => { | 427 | TypeNs::TypeAliasId(it) => { |
413 | Ty::from_hir_path_inner(ctx, resolved_segment, it.into(), infer_args) | 428 | self.lower_path_inner(resolved_segment, it.into(), infer_args) |
414 | } | 429 | } |
415 | // FIXME: report error | 430 | // FIXME: report error |
416 | TypeNs::EnumVariantId(_) => return (Ty::Unknown, None), | 431 | TypeNs::EnumVariantId(_) => return (TyKind::Unknown.intern(&Interner), None), |
417 | }; | 432 | }; |
418 | Ty::from_type_relative_path(ctx, ty, Some(resolution), remaining_segments) | 433 | self.lower_ty_relative_path(ty, Some(resolution), remaining_segments) |
419 | } | 434 | } |
420 | 435 | ||
421 | pub(crate) fn from_hir_path(ctx: &TyLoweringContext<'_>, path: &Path) -> (Ty, Option<TypeNs>) { | 436 | pub(crate) fn lower_path(&self, path: &Path) -> (Ty, Option<TypeNs>) { |
422 | // Resolve the path (in type namespace) | 437 | // Resolve the path (in type namespace) |
423 | if let Some(type_ref) = path.type_anchor() { | 438 | if let Some(type_ref) = path.type_anchor() { |
424 | let (ty, res) = Ty::from_hir_ext(ctx, &type_ref); | 439 | let (ty, res) = self.lower_ty_ext(&type_ref); |
425 | return Ty::from_type_relative_path(ctx, ty, res, path.segments()); | 440 | return self.lower_ty_relative_path(ty, res, path.segments()); |
426 | } | 441 | } |
427 | let (resolution, remaining_index) = | 442 | let (resolution, remaining_index) = |
428 | match ctx.resolver.resolve_path_in_type_ns(ctx.db.upcast(), path.mod_path()) { | 443 | match self.resolver.resolve_path_in_type_ns(self.db.upcast(), path.mod_path()) { |
429 | Some(it) => it, | 444 | Some(it) => it, |
430 | None => return (Ty::Unknown, None), | 445 | None => return (TyKind::Unknown.intern(&Interner), None), |
431 | }; | 446 | }; |
432 | let (resolved_segment, remaining_segments) = match remaining_index { | 447 | let (resolved_segment, remaining_segments) = match remaining_index { |
433 | None => ( | 448 | None => ( |
@@ -436,31 +451,23 @@ impl Ty { | |||
436 | ), | 451 | ), |
437 | Some(i) => (path.segments().get(i - 1).unwrap(), path.segments().skip(i)), | 452 | Some(i) => (path.segments().get(i - 1).unwrap(), path.segments().skip(i)), |
438 | }; | 453 | }; |
439 | Ty::from_partly_resolved_hir_path( | 454 | self.lower_partly_resolved_path(resolution, resolved_segment, remaining_segments, false) |
440 | ctx, | ||
441 | resolution, | ||
442 | resolved_segment, | ||
443 | remaining_segments, | ||
444 | false, | ||
445 | ) | ||
446 | } | 455 | } |
447 | 456 | ||
448 | fn select_associated_type( | 457 | fn select_associated_type(&self, res: Option<TypeNs>, segment: PathSegment<'_>) -> Ty { |
449 | ctx: &TyLoweringContext<'_>, | ||
450 | res: Option<TypeNs>, | ||
451 | segment: PathSegment<'_>, | ||
452 | ) -> Ty { | ||
453 | if let Some(res) = res { | 458 | if let Some(res) = res { |
454 | let ty = | 459 | let ty = associated_type_shorthand_candidates( |
455 | associated_type_shorthand_candidates(ctx.db, res, move |name, t, associated_ty| { | 460 | self.db, |
461 | res, | ||
462 | move |name, t, associated_ty| { | ||
456 | if name == segment.name { | 463 | if name == segment.name { |
457 | let substs = match ctx.type_param_mode { | 464 | let substs = match self.type_param_mode { |
458 | TypeParamLoweringMode::Placeholder => { | 465 | TypeParamLoweringMode::Placeholder => { |
459 | // if we're lowering to placeholders, we have to put | 466 | // if we're lowering to placeholders, we have to put |
460 | // them in now | 467 | // them in now |
461 | let s = Substs::type_params( | 468 | let s = Substs::type_params( |
462 | ctx.db, | 469 | self.db, |
463 | ctx.resolver.generic_def().expect( | 470 | self.resolver.generic_def().expect( |
464 | "there should be generics if there's a generic param", | 471 | "there should be generics if there's a generic param", |
465 | ), | 472 | ), |
466 | ); | 473 | ); |
@@ -470,25 +477,29 @@ impl Ty { | |||
470 | }; | 477 | }; |
471 | // We need to shift in the bound vars, since | 478 | // We need to shift in the bound vars, since |
472 | // associated_type_shorthand_candidates does not do that | 479 | // associated_type_shorthand_candidates does not do that |
473 | let substs = substs.shift_bound_vars(ctx.in_binders); | 480 | let substs = substs.shift_bound_vars(self.in_binders); |
474 | // FIXME handle type parameters on the segment | 481 | // FIXME handle type parameters on the segment |
475 | return Some(Ty::Alias(AliasTy::Projection(ProjectionTy { | 482 | return Some( |
476 | associated_ty, | 483 | TyKind::Alias(AliasTy::Projection(ProjectionTy { |
477 | parameters: substs, | 484 | associated_ty_id: to_assoc_type_id(associated_ty), |
478 | }))); | 485 | substitution: substs, |
486 | })) | ||
487 | .intern(&Interner), | ||
488 | ); | ||
479 | } | 489 | } |
480 | 490 | ||
481 | None | 491 | None |
482 | }); | 492 | }, |
493 | ); | ||
483 | 494 | ||
484 | ty.unwrap_or(Ty::Unknown) | 495 | ty.unwrap_or(TyKind::Unknown.intern(&Interner)) |
485 | } else { | 496 | } else { |
486 | Ty::Unknown | 497 | TyKind::Unknown.intern(&Interner) |
487 | } | 498 | } |
488 | } | 499 | } |
489 | 500 | ||
490 | fn from_hir_path_inner( | 501 | fn lower_path_inner( |
491 | ctx: &TyLoweringContext<'_>, | 502 | &self, |
492 | segment: PathSegment<'_>, | 503 | segment: PathSegment<'_>, |
493 | typeable: TyDefId, | 504 | typeable: TyDefId, |
494 | infer_args: bool, | 505 | infer_args: bool, |
@@ -498,14 +509,14 @@ impl Ty { | |||
498 | TyDefId::AdtId(it) => Some(it.into()), | 509 | TyDefId::AdtId(it) => Some(it.into()), |
499 | TyDefId::TypeAliasId(it) => Some(it.into()), | 510 | TyDefId::TypeAliasId(it) => Some(it.into()), |
500 | }; | 511 | }; |
501 | let substs = substs_from_path_segment(ctx, segment, generic_def, infer_args); | 512 | let substs = self.substs_from_path_segment(segment, generic_def, infer_args); |
502 | ctx.db.ty(typeable).subst(&substs) | 513 | self.db.ty(typeable).subst(&substs) |
503 | } | 514 | } |
504 | 515 | ||
505 | /// Collect generic arguments from a path into a `Substs`. See also | 516 | /// Collect generic arguments from a path into a `Substs`. See also |
506 | /// `create_substs_for_ast_path` and `def_to_ty` in rustc. | 517 | /// `create_substs_for_ast_path` and `def_to_ty` in rustc. |
507 | pub(super) fn substs_from_path( | 518 | pub(super) fn substs_from_path( |
508 | ctx: &TyLoweringContext<'_>, | 519 | &self, |
509 | path: &Path, | 520 | path: &Path, |
510 | // Note that we don't call `db.value_type(resolved)` here, | 521 | // Note that we don't call `db.value_type(resolved)` here, |
511 | // `ValueTyDefId` is just a convenient way to pass generics and | 522 | // `ValueTyDefId` is just a convenient way to pass generics and |
@@ -535,169 +546,161 @@ impl Ty { | |||
535 | (segment, Some(var.parent.into())) | 546 | (segment, Some(var.parent.into())) |
536 | } | 547 | } |
537 | }; | 548 | }; |
538 | substs_from_path_segment(ctx, segment, generic_def, infer_args) | 549 | self.substs_from_path_segment(segment, generic_def, infer_args) |
539 | } | 550 | } |
540 | } | ||
541 | 551 | ||
542 | fn substs_from_path_segment( | 552 | fn substs_from_path_segment( |
543 | ctx: &TyLoweringContext<'_>, | 553 | &self, |
544 | segment: PathSegment<'_>, | 554 | segment: PathSegment<'_>, |
545 | def_generic: Option<GenericDefId>, | 555 | def_generic: Option<GenericDefId>, |
546 | infer_args: bool, | 556 | infer_args: bool, |
547 | ) -> Substs { | 557 | ) -> Substs { |
548 | let mut substs = Vec::new(); | 558 | let mut substs = Vec::new(); |
549 | let def_generics = def_generic.map(|def| generics(ctx.db.upcast(), def)); | 559 | let def_generics = def_generic.map(|def| generics(self.db.upcast(), def)); |
550 | 560 | ||
551 | let (parent_params, self_params, type_params, impl_trait_params) = | 561 | let (parent_params, self_params, type_params, impl_trait_params) = |
552 | def_generics.map_or((0, 0, 0, 0), |g| g.provenance_split()); | 562 | def_generics.map_or((0, 0, 0, 0), |g| g.provenance_split()); |
553 | let total_len = parent_params + self_params + type_params + impl_trait_params; | 563 | let total_len = parent_params + self_params + type_params + impl_trait_params; |
554 | 564 | ||
555 | substs.extend(iter::repeat(Ty::Unknown).take(parent_params)); | 565 | substs.extend(iter::repeat(TyKind::Unknown.intern(&Interner)).take(parent_params)); |
556 | 566 | ||
557 | let mut had_explicit_type_args = false; | 567 | let mut had_explicit_type_args = false; |
558 | 568 | ||
559 | if let Some(generic_args) = &segment.args_and_bindings { | 569 | if let Some(generic_args) = &segment.args_and_bindings { |
560 | if !generic_args.has_self_type { | 570 | if !generic_args.has_self_type { |
561 | substs.extend(iter::repeat(Ty::Unknown).take(self_params)); | 571 | substs.extend(iter::repeat(TyKind::Unknown.intern(&Interner)).take(self_params)); |
562 | } | 572 | } |
563 | let expected_num = | 573 | let expected_num = |
564 | if generic_args.has_self_type { self_params + type_params } else { type_params }; | 574 | if generic_args.has_self_type { self_params + type_params } else { type_params }; |
565 | let skip = if generic_args.has_self_type && self_params == 0 { 1 } else { 0 }; | 575 | let skip = if generic_args.has_self_type && self_params == 0 { 1 } else { 0 }; |
566 | // if args are provided, it should be all of them, but we can't rely on that | 576 | // if args are provided, it should be all of them, but we can't rely on that |
567 | for arg in generic_args | 577 | for arg in generic_args |
568 | .args | 578 | .args |
569 | .iter() | 579 | .iter() |
570 | .filter(|arg| matches!(arg, GenericArg::Type(_))) | 580 | .filter(|arg| matches!(arg, GenericArg::Type(_))) |
571 | .skip(skip) | 581 | .skip(skip) |
572 | .take(expected_num) | 582 | .take(expected_num) |
573 | { | 583 | { |
574 | match arg { | 584 | match arg { |
575 | GenericArg::Type(type_ref) => { | 585 | GenericArg::Type(type_ref) => { |
576 | had_explicit_type_args = true; | 586 | had_explicit_type_args = true; |
577 | let ty = Ty::from_hir(ctx, type_ref); | 587 | let ty = self.lower_ty(type_ref); |
578 | substs.push(ty); | 588 | substs.push(ty); |
589 | } | ||
590 | GenericArg::Lifetime(_) => {} | ||
579 | } | 591 | } |
580 | GenericArg::Lifetime(_) => {} | ||
581 | } | 592 | } |
582 | } | 593 | } |
583 | } | ||
584 | 594 | ||
585 | // handle defaults. In expression or pattern path segments without | 595 | // handle defaults. In expression or pattern path segments without |
586 | // explicitly specified type arguments, missing type arguments are inferred | 596 | // explicitly specified type arguments, missing type arguments are inferred |
587 | // (i.e. defaults aren't used). | 597 | // (i.e. defaults aren't used). |
588 | if !infer_args || had_explicit_type_args { | 598 | if !infer_args || had_explicit_type_args { |
589 | if let Some(def_generic) = def_generic { | 599 | if let Some(def_generic) = def_generic { |
590 | let defaults = ctx.db.generic_defaults(def_generic); | 600 | let defaults = self.db.generic_defaults(def_generic); |
591 | assert_eq!(total_len, defaults.len()); | 601 | assert_eq!(total_len, defaults.len()); |
592 | 602 | ||
593 | for default_ty in defaults.iter().skip(substs.len()) { | 603 | for default_ty in defaults.iter().skip(substs.len()) { |
594 | // each default can depend on the previous parameters | 604 | // each default can depend on the previous parameters |
595 | let substs_so_far = Substs(substs.clone().into()); | 605 | let substs_so_far = Substs(substs.clone().into()); |
596 | substs.push(default_ty.clone().subst(&substs_so_far)); | 606 | substs.push(default_ty.clone().subst(&substs_so_far)); |
607 | } | ||
597 | } | 608 | } |
598 | } | 609 | } |
599 | } | ||
600 | 610 | ||
601 | // add placeholders for args that were not provided | 611 | // add placeholders for args that were not provided |
602 | // FIXME: emit diagnostics in contexts where this is not allowed | 612 | // FIXME: emit diagnostics in contexts where this is not allowed |
603 | for _ in substs.len()..total_len { | 613 | for _ in substs.len()..total_len { |
604 | substs.push(Ty::Unknown); | 614 | substs.push(TyKind::Unknown.intern(&Interner)); |
605 | } | 615 | } |
606 | assert_eq!(substs.len(), total_len); | 616 | assert_eq!(substs.len(), total_len); |
607 | 617 | ||
608 | Substs(substs.into()) | 618 | Substs(substs.into()) |
609 | } | 619 | } |
610 | 620 | ||
611 | impl TraitRef { | 621 | fn lower_trait_ref_from_path( |
612 | fn from_path( | 622 | &self, |
613 | ctx: &TyLoweringContext<'_>, | ||
614 | path: &Path, | 623 | path: &Path, |
615 | explicit_self_ty: Option<Ty>, | 624 | explicit_self_ty: Option<Ty>, |
616 | ) -> Option<Self> { | 625 | ) -> Option<TraitRef> { |
617 | let resolved = | 626 | let resolved = |
618 | match ctx.resolver.resolve_path_in_type_ns_fully(ctx.db.upcast(), path.mod_path())? { | 627 | match self.resolver.resolve_path_in_type_ns_fully(self.db.upcast(), path.mod_path())? { |
619 | TypeNs::TraitId(tr) => tr, | 628 | TypeNs::TraitId(tr) => tr, |
620 | _ => return None, | 629 | _ => return None, |
621 | }; | 630 | }; |
622 | let segment = path.segments().last().expect("path should have at least one segment"); | 631 | let segment = path.segments().last().expect("path should have at least one segment"); |
623 | Some(TraitRef::from_resolved_path(ctx, resolved, segment, explicit_self_ty)) | 632 | Some(self.lower_trait_ref_from_resolved_path(resolved, segment, explicit_self_ty)) |
624 | } | 633 | } |
625 | 634 | ||
626 | pub(crate) fn from_resolved_path( | 635 | pub(crate) fn lower_trait_ref_from_resolved_path( |
627 | ctx: &TyLoweringContext<'_>, | 636 | &self, |
628 | resolved: TraitId, | 637 | resolved: TraitId, |
629 | segment: PathSegment<'_>, | 638 | segment: PathSegment<'_>, |
630 | explicit_self_ty: Option<Ty>, | 639 | explicit_self_ty: Option<Ty>, |
631 | ) -> Self { | 640 | ) -> TraitRef { |
632 | let mut substs = TraitRef::substs_from_path(ctx, segment, resolved); | 641 | let mut substs = self.trait_ref_substs_from_path(segment, resolved); |
633 | if let Some(self_ty) = explicit_self_ty { | 642 | if let Some(self_ty) = explicit_self_ty { |
634 | make_mut_slice(&mut substs.0)[0] = self_ty; | 643 | make_mut_slice(&mut substs.0)[0] = self_ty; |
635 | } | 644 | } |
636 | TraitRef { trait_: resolved, substs } | 645 | TraitRef { trait_: resolved, substs } |
637 | } | 646 | } |
638 | 647 | ||
639 | fn from_hir( | 648 | fn lower_trait_ref( |
640 | ctx: &TyLoweringContext<'_>, | 649 | &self, |
641 | type_ref: &TypeRef, | 650 | type_ref: &TypeRef, |
642 | explicit_self_ty: Option<Ty>, | 651 | explicit_self_ty: Option<Ty>, |
643 | ) -> Option<Self> { | 652 | ) -> Option<TraitRef> { |
644 | let path = match type_ref { | 653 | let path = match type_ref { |
645 | TypeRef::Path(path) => path, | 654 | TypeRef::Path(path) => path, |
646 | _ => return None, | 655 | _ => return None, |
647 | }; | 656 | }; |
648 | TraitRef::from_path(ctx, path, explicit_self_ty) | 657 | self.lower_trait_ref_from_path(path, explicit_self_ty) |
649 | } | 658 | } |
650 | 659 | ||
651 | fn substs_from_path( | 660 | fn trait_ref_substs_from_path(&self, segment: PathSegment<'_>, resolved: TraitId) -> Substs { |
652 | ctx: &TyLoweringContext<'_>, | 661 | self.substs_from_path_segment(segment, Some(resolved.into()), false) |
653 | segment: PathSegment<'_>, | ||
654 | resolved: TraitId, | ||
655 | ) -> Substs { | ||
656 | substs_from_path_segment(ctx, segment, Some(resolved.into()), false) | ||
657 | } | 662 | } |
658 | } | ||
659 | 663 | ||
660 | impl GenericPredicate { | 664 | pub(crate) fn lower_where_predicate( |
661 | pub(crate) fn from_where_predicate<'a>( | 665 | &'a self, |
662 | ctx: &'a TyLoweringContext<'a>, | ||
663 | where_predicate: &'a WherePredicate, | 666 | where_predicate: &'a WherePredicate, |
664 | ) -> impl Iterator<Item = GenericPredicate> + 'a { | 667 | ) -> impl Iterator<Item = GenericPredicate> + 'a { |
665 | match where_predicate { | 668 | match where_predicate { |
666 | WherePredicate::ForLifetime { target, bound, .. } | 669 | WherePredicate::ForLifetime { target, bound, .. } |
667 | | WherePredicate::TypeBound { target, bound } => { | 670 | | WherePredicate::TypeBound { target, bound } => { |
668 | let self_ty = match target { | 671 | let self_ty = match target { |
669 | WherePredicateTypeTarget::TypeRef(type_ref) => Ty::from_hir(ctx, type_ref), | 672 | WherePredicateTypeTarget::TypeRef(type_ref) => self.lower_ty(type_ref), |
670 | WherePredicateTypeTarget::TypeParam(param_id) => { | 673 | WherePredicateTypeTarget::TypeParam(param_id) => { |
671 | let generic_def = ctx.resolver.generic_def().expect("generics in scope"); | 674 | let generic_def = self.resolver.generic_def().expect("generics in scope"); |
672 | let generics = generics(ctx.db.upcast(), generic_def); | 675 | let generics = generics(self.db.upcast(), generic_def); |
673 | let param_id = | 676 | let param_id = |
674 | hir_def::TypeParamId { parent: generic_def, local_id: *param_id }; | 677 | hir_def::TypeParamId { parent: generic_def, local_id: *param_id }; |
675 | match ctx.type_param_mode { | 678 | let placeholder = to_placeholder_idx(self.db, param_id); |
676 | TypeParamLoweringMode::Placeholder => Ty::Placeholder(param_id), | 679 | match self.type_param_mode { |
680 | TypeParamLoweringMode::Placeholder => TyKind::Placeholder(placeholder), | ||
677 | TypeParamLoweringMode::Variable => { | 681 | TypeParamLoweringMode::Variable => { |
678 | let idx = generics.param_idx(param_id).expect("matching generics"); | 682 | let idx = generics.param_idx(param_id).expect("matching generics"); |
679 | Ty::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, idx)) | 683 | TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, idx)) |
680 | } | 684 | } |
681 | } | 685 | } |
686 | .intern(&Interner) | ||
682 | } | 687 | } |
683 | }; | 688 | }; |
684 | GenericPredicate::from_type_bound(ctx, bound, self_ty) | 689 | self.lower_type_bound(bound, self_ty).collect::<Vec<_>>().into_iter() |
685 | .collect::<Vec<_>>() | ||
686 | .into_iter() | ||
687 | } | 690 | } |
688 | WherePredicate::Lifetime { .. } => vec![].into_iter(), | 691 | WherePredicate::Lifetime { .. } => vec![].into_iter(), |
689 | } | 692 | } |
690 | } | 693 | } |
691 | 694 | ||
692 | pub(crate) fn from_type_bound<'a>( | 695 | pub(crate) fn lower_type_bound( |
693 | ctx: &'a TyLoweringContext<'a>, | 696 | &'a self, |
694 | bound: &'a TypeBound, | 697 | bound: &'a TypeBound, |
695 | self_ty: Ty, | 698 | self_ty: Ty, |
696 | ) -> impl Iterator<Item = GenericPredicate> + 'a { | 699 | ) -> impl Iterator<Item = GenericPredicate> + 'a { |
697 | let mut bindings = None; | 700 | let mut bindings = None; |
698 | let trait_ref = match bound { | 701 | let trait_ref = match bound { |
699 | TypeBound::Path(path) => { | 702 | TypeBound::Path(path) => { |
700 | bindings = TraitRef::from_path(ctx, path, Some(self_ty)); | 703 | bindings = self.lower_trait_ref_from_path(path, Some(self_ty)); |
701 | Some( | 704 | Some( |
702 | bindings.clone().map_or(GenericPredicate::Error, GenericPredicate::Implemented), | 705 | bindings.clone().map_or(GenericPredicate::Error, GenericPredicate::Implemented), |
703 | ) | 706 | ) |
@@ -708,64 +711,62 @@ impl GenericPredicate { | |||
708 | trait_ref.into_iter().chain( | 711 | trait_ref.into_iter().chain( |
709 | bindings | 712 | bindings |
710 | .into_iter() | 713 | .into_iter() |
711 | .flat_map(move |tr| assoc_type_bindings_from_type_bound(ctx, bound, tr)), | 714 | .flat_map(move |tr| self.assoc_type_bindings_from_type_bound(bound, tr)), |
712 | ) | 715 | ) |
713 | } | 716 | } |
714 | } | ||
715 | 717 | ||
716 | fn assoc_type_bindings_from_type_bound<'a>( | 718 | fn assoc_type_bindings_from_type_bound( |
717 | ctx: &'a TyLoweringContext<'a>, | 719 | &'a self, |
718 | bound: &'a TypeBound, | 720 | bound: &'a TypeBound, |
719 | trait_ref: TraitRef, | 721 | trait_ref: TraitRef, |
720 | ) -> impl Iterator<Item = GenericPredicate> + 'a { | 722 | ) -> impl Iterator<Item = GenericPredicate> + 'a { |
721 | let last_segment = match bound { | 723 | let last_segment = match bound { |
722 | TypeBound::Path(path) => path.segments().last(), | 724 | TypeBound::Path(path) => path.segments().last(), |
723 | TypeBound::Error | TypeBound::Lifetime(_) => None, | 725 | TypeBound::Error | TypeBound::Lifetime(_) => None, |
724 | }; | 726 | }; |
725 | last_segment | 727 | last_segment |
726 | .into_iter() | 728 | .into_iter() |
727 | .flat_map(|segment| segment.args_and_bindings.into_iter()) | 729 | .flat_map(|segment| segment.args_and_bindings.into_iter()) |
728 | .flat_map(|args_and_bindings| args_and_bindings.bindings.iter()) | 730 | .flat_map(|args_and_bindings| args_and_bindings.bindings.iter()) |
729 | .flat_map(move |binding| { | 731 | .flat_map(move |binding| { |
730 | let found = associated_type_by_name_including_super_traits( | 732 | let found = associated_type_by_name_including_super_traits( |
731 | ctx.db, | 733 | self.db, |
732 | trait_ref.clone(), | 734 | trait_ref.clone(), |
733 | &binding.name, | 735 | &binding.name, |
734 | ); | 736 | ); |
735 | let (super_trait_ref, associated_ty) = match found { | 737 | let (super_trait_ref, associated_ty) = match found { |
736 | None => return SmallVec::<[GenericPredicate; 1]>::new(), | 738 | None => return SmallVec::<[GenericPredicate; 1]>::new(), |
737 | Some(t) => t, | 739 | Some(t) => t, |
738 | }; | 740 | }; |
739 | let projection_ty = ProjectionTy { associated_ty, parameters: super_trait_ref.substs }; | 741 | let projection_ty = ProjectionTy { |
740 | let mut preds = SmallVec::with_capacity( | 742 | associated_ty_id: to_assoc_type_id(associated_ty), |
741 | binding.type_ref.as_ref().map_or(0, |_| 1) + binding.bounds.len(), | 743 | substitution: super_trait_ref.substs, |
742 | ); | 744 | }; |
743 | if let Some(type_ref) = &binding.type_ref { | 745 | let mut preds = SmallVec::with_capacity( |
744 | let ty = Ty::from_hir(ctx, type_ref); | 746 | binding.type_ref.as_ref().map_or(0, |_| 1) + binding.bounds.len(), |
745 | let projection_predicate = | 747 | ); |
746 | ProjectionPredicate { projection_ty: projection_ty.clone(), ty }; | 748 | if let Some(type_ref) = &binding.type_ref { |
747 | preds.push(GenericPredicate::Projection(projection_predicate)); | 749 | let ty = self.lower_ty(type_ref); |
748 | } | 750 | let projection_predicate = |
749 | for bound in &binding.bounds { | 751 | ProjectionPredicate { projection_ty: projection_ty.clone(), ty }; |
750 | preds.extend(GenericPredicate::from_type_bound( | 752 | preds.push(GenericPredicate::Projection(projection_predicate)); |
751 | ctx, | 753 | } |
752 | bound, | 754 | for bound in &binding.bounds { |
753 | Ty::Alias(AliasTy::Projection(projection_ty.clone())), | 755 | preds.extend(self.lower_type_bound( |
754 | )); | 756 | bound, |
755 | } | 757 | TyKind::Alias(AliasTy::Projection(projection_ty.clone())).intern(&Interner), |
756 | preds | 758 | )); |
757 | }) | 759 | } |
758 | } | 760 | preds |
761 | }) | ||
762 | } | ||
759 | 763 | ||
760 | impl ReturnTypeImplTrait { | 764 | fn lower_impl_trait(&self, bounds: &[TypeBound]) -> ReturnTypeImplTrait { |
761 | fn from_hir(ctx: &TyLoweringContext, bounds: &[TypeBound]) -> Self { | ||
762 | cov_mark::hit!(lower_rpit); | 765 | cov_mark::hit!(lower_rpit); |
763 | let self_ty = Ty::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0)); | 766 | let self_ty = |
764 | let predicates = ctx.with_shifted_in(DebruijnIndex::ONE, |ctx| { | 767 | TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0)).intern(&Interner); |
765 | bounds | 768 | let predicates = self.with_shifted_in(DebruijnIndex::ONE, |ctx| { |
766 | .iter() | 769 | bounds.iter().flat_map(|b| ctx.lower_type_bound(b, self_ty.clone())).collect() |
767 | .flat_map(|b| GenericPredicate::from_type_bound(ctx, b, self_ty.clone())) | ||
768 | .collect() | ||
769 | }); | 770 | }); |
770 | ReturnTypeImplTrait { bounds: Binders::new(1, predicates) } | 771 | ReturnTypeImplTrait { bounds: Binders::new(1, predicates) } |
771 | } | 772 | } |
@@ -861,7 +862,7 @@ pub(crate) fn field_types_query( | |||
861 | let ctx = | 862 | let ctx = |
862 | TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable); | 863 | TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable); |
863 | for (field_id, field_data) in var_data.fields().iter() { | 864 | for (field_id, field_data) in var_data.fields().iter() { |
864 | res.insert(field_id, Binders::new(generics.len(), Ty::from_hir(&ctx, &field_data.type_ref))) | 865 | res.insert(field_id, Binders::new(generics.len(), ctx.lower_ty(&field_data.type_ref))) |
865 | } | 866 | } |
866 | Arc::new(res) | 867 | Arc::new(res) |
867 | } | 868 | } |
@@ -889,16 +890,13 @@ pub(crate) fn generic_predicates_for_param_query( | |||
889 | WherePredicate::ForLifetime { target, .. } | 890 | WherePredicate::ForLifetime { target, .. } |
890 | | WherePredicate::TypeBound { target, .. } => match target { | 891 | | WherePredicate::TypeBound { target, .. } => match target { |
891 | WherePredicateTypeTarget::TypeRef(type_ref) => { | 892 | WherePredicateTypeTarget::TypeRef(type_ref) => { |
892 | Ty::from_hir_only_param(&ctx, type_ref) == Some(param_id) | 893 | ctx.lower_ty_only_param(type_ref) == Some(param_id) |
893 | } | 894 | } |
894 | WherePredicateTypeTarget::TypeParam(local_id) => *local_id == param_id.local_id, | 895 | WherePredicateTypeTarget::TypeParam(local_id) => *local_id == param_id.local_id, |
895 | }, | 896 | }, |
896 | WherePredicate::Lifetime { .. } => false, | 897 | WherePredicate::Lifetime { .. } => false, |
897 | }) | 898 | }) |
898 | .flat_map(|pred| { | 899 | .flat_map(|pred| ctx.lower_where_predicate(pred).map(|p| Binders::new(generics.len(), p))) |
899 | GenericPredicate::from_where_predicate(&ctx, pred) | ||
900 | .map(|p| Binders::new(generics.len(), p)) | ||
901 | }) | ||
902 | .collect() | 900 | .collect() |
903 | } | 901 | } |
904 | 902 | ||
@@ -910,41 +908,55 @@ pub(crate) fn generic_predicates_for_param_recover( | |||
910 | Arc::new([]) | 908 | Arc::new([]) |
911 | } | 909 | } |
912 | 910 | ||
913 | impl TraitEnvironment { | 911 | pub(crate) fn trait_environment_query( |
914 | pub fn lower(db: &dyn HirDatabase, resolver: &Resolver) -> Arc<TraitEnvironment> { | 912 | db: &dyn HirDatabase, |
915 | let ctx = TyLoweringContext::new(db, &resolver) | 913 | def: GenericDefId, |
916 | .with_type_param_mode(TypeParamLoweringMode::Placeholder); | 914 | ) -> Arc<TraitEnvironment> { |
917 | let mut predicates = resolver | 915 | let resolver = def.resolver(db.upcast()); |
918 | .where_predicates_in_scope() | 916 | let ctx = TyLoweringContext::new(db, &resolver) |
919 | .flat_map(|pred| GenericPredicate::from_where_predicate(&ctx, pred)) | 917 | .with_type_param_mode(TypeParamLoweringMode::Placeholder); |
920 | .collect::<Vec<_>>(); | 918 | let mut traits_in_scope = Vec::new(); |
921 | 919 | let mut clauses = Vec::new(); | |
922 | if let Some(def) = resolver.generic_def() { | 920 | for pred in resolver.where_predicates_in_scope() { |
923 | let container: Option<AssocContainerId> = match def { | 921 | for pred in ctx.lower_where_predicate(pred) { |
924 | // FIXME: is there a function for this? | 922 | if pred.is_error() { |
925 | GenericDefId::FunctionId(f) => Some(f.lookup(db.upcast()).container), | 923 | continue; |
926 | GenericDefId::AdtId(_) => None, | ||
927 | GenericDefId::TraitId(_) => None, | ||
928 | GenericDefId::TypeAliasId(t) => Some(t.lookup(db.upcast()).container), | ||
929 | GenericDefId::ImplId(_) => None, | ||
930 | GenericDefId::EnumVariantId(_) => None, | ||
931 | GenericDefId::ConstId(c) => Some(c.lookup(db.upcast()).container), | ||
932 | }; | ||
933 | if let Some(AssocContainerId::TraitId(trait_id)) = container { | ||
934 | // add `Self: Trait<T1, T2, ...>` to the environment in trait | ||
935 | // function default implementations (and hypothetical code | ||
936 | // inside consts or type aliases) | ||
937 | cov_mark::hit!(trait_self_implements_self); | ||
938 | let substs = Substs::type_params(db, trait_id); | ||
939 | let trait_ref = TraitRef { trait_: trait_id, substs }; | ||
940 | let pred = GenericPredicate::Implemented(trait_ref); | ||
941 | |||
942 | predicates.push(pred); | ||
943 | } | 924 | } |
925 | if let GenericPredicate::Implemented(tr) = &pred { | ||
926 | traits_in_scope.push((tr.self_ty().clone(), tr.trait_)); | ||
927 | } | ||
928 | let program_clause: chalk_ir::ProgramClause<Interner> = | ||
929 | pred.clone().to_chalk(db).cast(&Interner); | ||
930 | clauses.push(program_clause.into_from_env_clause(&Interner)); | ||
944 | } | 931 | } |
932 | } | ||
945 | 933 | ||
946 | Arc::new(TraitEnvironment { predicates }) | 934 | let container: Option<AssocContainerId> = match def { |
935 | // FIXME: is there a function for this? | ||
936 | GenericDefId::FunctionId(f) => Some(f.lookup(db.upcast()).container), | ||
937 | GenericDefId::AdtId(_) => None, | ||
938 | GenericDefId::TraitId(_) => None, | ||
939 | GenericDefId::TypeAliasId(t) => Some(t.lookup(db.upcast()).container), | ||
940 | GenericDefId::ImplId(_) => None, | ||
941 | GenericDefId::EnumVariantId(_) => None, | ||
942 | GenericDefId::ConstId(c) => Some(c.lookup(db.upcast()).container), | ||
943 | }; | ||
944 | if let Some(AssocContainerId::TraitId(trait_id)) = container { | ||
945 | // add `Self: Trait<T1, T2, ...>` to the environment in trait | ||
946 | // function default implementations (and hypothetical code | ||
947 | // inside consts or type aliases) | ||
948 | cov_mark::hit!(trait_self_implements_self); | ||
949 | let substs = Substs::type_params(db, trait_id); | ||
950 | let trait_ref = TraitRef { trait_: trait_id, substs }; | ||
951 | let pred = GenericPredicate::Implemented(trait_ref); | ||
952 | let program_clause: chalk_ir::ProgramClause<Interner> = | ||
953 | pred.clone().to_chalk(db).cast(&Interner); | ||
954 | clauses.push(program_clause.into_from_env_clause(&Interner)); | ||
947 | } | 955 | } |
956 | |||
957 | let env = chalk_ir::Environment::new(&Interner).add_clauses(&Interner, clauses); | ||
958 | |||
959 | Arc::new(TraitEnvironment { traits_from_clauses: traits_in_scope, env }) | ||
948 | } | 960 | } |
949 | 961 | ||
950 | /// Resolve the where clause(s) of an item with generics. | 962 | /// Resolve the where clause(s) of an item with generics. |
@@ -958,10 +970,7 @@ pub(crate) fn generic_predicates_query( | |||
958 | let generics = generics(db.upcast(), def); | 970 | let generics = generics(db.upcast(), def); |
959 | resolver | 971 | resolver |
960 | .where_predicates_in_scope() | 972 | .where_predicates_in_scope() |
961 | .flat_map(|pred| { | 973 | .flat_map(|pred| ctx.lower_where_predicate(pred).map(|p| Binders::new(generics.len(), p))) |
962 | GenericPredicate::from_where_predicate(&ctx, pred) | ||
963 | .map(|p| Binders::new(generics.len(), p)) | ||
964 | }) | ||
965 | .collect() | 974 | .collect() |
966 | } | 975 | } |
967 | 976 | ||
@@ -979,17 +988,18 @@ pub(crate) fn generic_defaults_query( | |||
979 | .iter() | 988 | .iter() |
980 | .enumerate() | 989 | .enumerate() |
981 | .map(|(idx, (_, p))| { | 990 | .map(|(idx, (_, p))| { |
982 | let mut ty = p.default.as_ref().map_or(Ty::Unknown, |t| Ty::from_hir(&ctx, t)); | 991 | let mut ty = |
992 | p.default.as_ref().map_or(TyKind::Unknown.intern(&Interner), |t| ctx.lower_ty(t)); | ||
983 | 993 | ||
984 | // Each default can only refer to previous parameters. | 994 | // Each default can only refer to previous parameters. |
985 | ty.walk_mut_binders( | 995 | ty.walk_mut_binders( |
986 | &mut |ty, binders| match ty { | 996 | &mut |ty, binders| match &mut ty.0 { |
987 | Ty::BoundVar(BoundVar { debruijn, index }) if *debruijn == binders => { | 997 | TyKind::BoundVar(BoundVar { debruijn, index }) if *debruijn == binders => { |
988 | if *index >= idx { | 998 | if *index >= idx { |
989 | // type variable default referring to parameter coming | 999 | // type variable default referring to parameter coming |
990 | // after it. This is forbidden (FIXME: report | 1000 | // after it. This is forbidden (FIXME: report |
991 | // diagnostic) | 1001 | // diagnostic) |
992 | *ty = Ty::Unknown; | 1002 | *ty = TyKind::Unknown.intern(&Interner); |
993 | } | 1003 | } |
994 | } | 1004 | } |
995 | _ => {} | 1005 | _ => {} |
@@ -1010,11 +1020,11 @@ fn fn_sig_for_fn(db: &dyn HirDatabase, def: FunctionId) -> PolyFnSig { | |||
1010 | let ctx_params = TyLoweringContext::new(db, &resolver) | 1020 | let ctx_params = TyLoweringContext::new(db, &resolver) |
1011 | .with_impl_trait_mode(ImplTraitLoweringMode::Variable) | 1021 | .with_impl_trait_mode(ImplTraitLoweringMode::Variable) |
1012 | .with_type_param_mode(TypeParamLoweringMode::Variable); | 1022 | .with_type_param_mode(TypeParamLoweringMode::Variable); |
1013 | let params = data.params.iter().map(|tr| Ty::from_hir(&ctx_params, tr)).collect::<Vec<_>>(); | 1023 | let params = data.params.iter().map(|tr| (&ctx_params).lower_ty(tr)).collect::<Vec<_>>(); |
1014 | let ctx_ret = TyLoweringContext::new(db, &resolver) | 1024 | let ctx_ret = TyLoweringContext::new(db, &resolver) |
1015 | .with_impl_trait_mode(ImplTraitLoweringMode::Opaque) | 1025 | .with_impl_trait_mode(ImplTraitLoweringMode::Opaque) |
1016 | .with_type_param_mode(TypeParamLoweringMode::Variable); | 1026 | .with_type_param_mode(TypeParamLoweringMode::Variable); |
1017 | let ret = Ty::from_hir(&ctx_ret, &data.ret_type); | 1027 | let ret = (&ctx_ret).lower_ty(&data.ret_type); |
1018 | let generics = generics(db.upcast(), def.into()); | 1028 | let generics = generics(db.upcast(), def.into()); |
1019 | let num_binders = generics.len(); | 1029 | let num_binders = generics.len(); |
1020 | Binders::new(num_binders, CallableSig::from_params_and_return(params, ret, data.is_varargs)) | 1030 | Binders::new(num_binders, CallableSig::from_params_and_return(params, ret, data.is_varargs)) |
@@ -1025,7 +1035,10 @@ fn fn_sig_for_fn(db: &dyn HirDatabase, def: FunctionId) -> PolyFnSig { | |||
1025 | fn type_for_fn(db: &dyn HirDatabase, def: FunctionId) -> Binders<Ty> { | 1035 | fn type_for_fn(db: &dyn HirDatabase, def: FunctionId) -> Binders<Ty> { |
1026 | let generics = generics(db.upcast(), def.into()); | 1036 | let generics = generics(db.upcast(), def.into()); |
1027 | let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST); | 1037 | let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST); |
1028 | Binders::new(substs.len(), Ty::FnDef(def.into(), substs)) | 1038 | Binders::new( |
1039 | substs.len(), | ||
1040 | TyKind::FnDef(CallableDefId::FunctionId(def).to_chalk(db), substs).intern(&Interner), | ||
1041 | ) | ||
1029 | } | 1042 | } |
1030 | 1043 | ||
1031 | /// Build the declared type of a const. | 1044 | /// Build the declared type of a const. |
@@ -1036,7 +1049,7 @@ fn type_for_const(db: &dyn HirDatabase, def: ConstId) -> Binders<Ty> { | |||
1036 | let ctx = | 1049 | let ctx = |
1037 | TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable); | 1050 | TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable); |
1038 | 1051 | ||
1039 | Binders::new(generics.len(), Ty::from_hir(&ctx, &data.type_ref)) | 1052 | Binders::new(generics.len(), ctx.lower_ty(&data.type_ref)) |
1040 | } | 1053 | } |
1041 | 1054 | ||
1042 | /// Build the declared type of a static. | 1055 | /// Build the declared type of a static. |
@@ -1045,7 +1058,7 @@ fn type_for_static(db: &dyn HirDatabase, def: StaticId) -> Binders<Ty> { | |||
1045 | let resolver = def.resolver(db.upcast()); | 1058 | let resolver = def.resolver(db.upcast()); |
1046 | let ctx = TyLoweringContext::new(db, &resolver); | 1059 | let ctx = TyLoweringContext::new(db, &resolver); |
1047 | 1060 | ||
1048 | Binders::new(0, Ty::from_hir(&ctx, &data.type_ref)) | 1061 | Binders::new(0, ctx.lower_ty(&data.type_ref)) |
1049 | } | 1062 | } |
1050 | 1063 | ||
1051 | fn fn_sig_for_struct_constructor(db: &dyn HirDatabase, def: StructId) -> PolyFnSig { | 1064 | fn fn_sig_for_struct_constructor(db: &dyn HirDatabase, def: StructId) -> PolyFnSig { |
@@ -1054,8 +1067,7 @@ fn fn_sig_for_struct_constructor(db: &dyn HirDatabase, def: StructId) -> PolyFnS | |||
1054 | let resolver = def.resolver(db.upcast()); | 1067 | let resolver = def.resolver(db.upcast()); |
1055 | let ctx = | 1068 | let ctx = |
1056 | TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable); | 1069 | TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable); |
1057 | let params = | 1070 | let params = fields.iter().map(|(_, field)| ctx.lower_ty(&field.type_ref)).collect::<Vec<_>>(); |
1058 | fields.iter().map(|(_, field)| Ty::from_hir(&ctx, &field.type_ref)).collect::<Vec<_>>(); | ||
1059 | let ret = type_for_adt(db, def.into()); | 1071 | let ret = type_for_adt(db, def.into()); |
1060 | Binders::new(ret.num_binders, CallableSig::from_params_and_return(params, ret.value, false)) | 1072 | Binders::new(ret.num_binders, CallableSig::from_params_and_return(params, ret.value, false)) |
1061 | } | 1073 | } |
@@ -1068,7 +1080,10 @@ fn type_for_struct_constructor(db: &dyn HirDatabase, def: StructId) -> Binders<T | |||
1068 | } | 1080 | } |
1069 | let generics = generics(db.upcast(), def.into()); | 1081 | let generics = generics(db.upcast(), def.into()); |
1070 | let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST); | 1082 | let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST); |
1071 | Binders::new(substs.len(), Ty::FnDef(def.into(), substs)) | 1083 | Binders::new( |
1084 | substs.len(), | ||
1085 | TyKind::FnDef(CallableDefId::StructId(def).to_chalk(db), substs).intern(&Interner), | ||
1086 | ) | ||
1072 | } | 1087 | } |
1073 | 1088 | ||
1074 | fn fn_sig_for_enum_variant_constructor(db: &dyn HirDatabase, def: EnumVariantId) -> PolyFnSig { | 1089 | fn fn_sig_for_enum_variant_constructor(db: &dyn HirDatabase, def: EnumVariantId) -> PolyFnSig { |
@@ -1078,8 +1093,7 @@ fn fn_sig_for_enum_variant_constructor(db: &dyn HirDatabase, def: EnumVariantId) | |||
1078 | let resolver = def.parent.resolver(db.upcast()); | 1093 | let resolver = def.parent.resolver(db.upcast()); |
1079 | let ctx = | 1094 | let ctx = |
1080 | TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable); | 1095 | TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable); |
1081 | let params = | 1096 | let params = fields.iter().map(|(_, field)| ctx.lower_ty(&field.type_ref)).collect::<Vec<_>>(); |
1082 | fields.iter().map(|(_, field)| Ty::from_hir(&ctx, &field.type_ref)).collect::<Vec<_>>(); | ||
1083 | let ret = type_for_adt(db, def.parent.into()); | 1097 | let ret = type_for_adt(db, def.parent.into()); |
1084 | Binders::new(ret.num_binders, CallableSig::from_params_and_return(params, ret.value, false)) | 1098 | Binders::new(ret.num_binders, CallableSig::from_params_and_return(params, ret.value, false)) |
1085 | } | 1099 | } |
@@ -1093,7 +1107,10 @@ fn type_for_enum_variant_constructor(db: &dyn HirDatabase, def: EnumVariantId) - | |||
1093 | } | 1107 | } |
1094 | let generics = generics(db.upcast(), def.parent.into()); | 1108 | let generics = generics(db.upcast(), def.parent.into()); |
1095 | let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST); | 1109 | let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST); |
1096 | Binders::new(substs.len(), Ty::FnDef(def.into(), substs)) | 1110 | Binders::new( |
1111 | substs.len(), | ||
1112 | TyKind::FnDef(CallableDefId::EnumVariantId(def).to_chalk(db), substs).intern(&Interner), | ||
1113 | ) | ||
1097 | } | 1114 | } |
1098 | 1115 | ||
1099 | fn type_for_adt(db: &dyn HirDatabase, adt: AdtId) -> Binders<Ty> { | 1116 | fn type_for_adt(db: &dyn HirDatabase, adt: AdtId) -> Binders<Ty> { |
@@ -1108,11 +1125,11 @@ fn type_for_type_alias(db: &dyn HirDatabase, t: TypeAliasId) -> Binders<Ty> { | |||
1108 | let ctx = | 1125 | let ctx = |
1109 | TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable); | 1126 | TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable); |
1110 | if db.type_alias_data(t).is_extern { | 1127 | if db.type_alias_data(t).is_extern { |
1111 | Binders::new(0, Ty::ForeignType(t)) | 1128 | Binders::new(0, TyKind::ForeignType(crate::to_foreign_def_id(t)).intern(&Interner)) |
1112 | } else { | 1129 | } else { |
1113 | let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST); | 1130 | let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST); |
1114 | let type_ref = &db.type_alias_data(t).type_ref; | 1131 | let type_ref = &db.type_alias_data(t).type_ref; |
1115 | let inner = Ty::from_hir(&ctx, type_ref.as_ref().unwrap_or(&TypeRef::Error)); | 1132 | let inner = ctx.lower_ty(type_ref.as_ref().unwrap_or(&TypeRef::Error)); |
1116 | Binders::new(substs.len(), inner) | 1133 | Binders::new(substs.len(), inner) |
1117 | } | 1134 | } |
1118 | } | 1135 | } |
@@ -1184,7 +1201,7 @@ pub(crate) fn ty_recover(db: &dyn HirDatabase, _cycle: &[String], def: &TyDefId) | |||
1184 | TyDefId::AdtId(it) => generics(db.upcast(), it.into()).len(), | 1201 | TyDefId::AdtId(it) => generics(db.upcast(), it.into()).len(), |
1185 | TyDefId::TypeAliasId(it) => generics(db.upcast(), it.into()).len(), | 1202 | TyDefId::TypeAliasId(it) => generics(db.upcast(), it.into()).len(), |
1186 | }; | 1203 | }; |
1187 | Binders::new(num_binders, Ty::Unknown) | 1204 | Binders::new(num_binders, TyKind::Unknown.intern(&Interner)) |
1188 | } | 1205 | } |
1189 | 1206 | ||
1190 | pub(crate) fn value_ty_query(db: &dyn HirDatabase, def: ValueTyDefId) -> Binders<Ty> { | 1207 | pub(crate) fn value_ty_query(db: &dyn HirDatabase, def: ValueTyDefId) -> Binders<Ty> { |
@@ -1204,7 +1221,7 @@ pub(crate) fn impl_self_ty_query(db: &dyn HirDatabase, impl_id: ImplId) -> Binde | |||
1204 | let generics = generics(db.upcast(), impl_id.into()); | 1221 | let generics = generics(db.upcast(), impl_id.into()); |
1205 | let ctx = | 1222 | let ctx = |
1206 | TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable); | 1223 | TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable); |
1207 | Binders::new(generics.len(), Ty::from_hir(&ctx, &impl_data.target_type)) | 1224 | Binders::new(generics.len(), ctx.lower_ty(&impl_data.target_type)) |
1208 | } | 1225 | } |
1209 | 1226 | ||
1210 | pub(crate) fn const_param_ty_query(db: &dyn HirDatabase, def: ConstParamId) -> Ty { | 1227 | pub(crate) fn const_param_ty_query(db: &dyn HirDatabase, def: ConstParamId) -> Ty { |
@@ -1213,7 +1230,7 @@ pub(crate) fn const_param_ty_query(db: &dyn HirDatabase, def: ConstParamId) -> T | |||
1213 | let resolver = def.parent.resolver(db.upcast()); | 1230 | let resolver = def.parent.resolver(db.upcast()); |
1214 | let ctx = TyLoweringContext::new(db, &resolver); | 1231 | let ctx = TyLoweringContext::new(db, &resolver); |
1215 | 1232 | ||
1216 | Ty::from_hir(&ctx, &data.ty) | 1233 | ctx.lower_ty(&data.ty) |
1217 | } | 1234 | } |
1218 | 1235 | ||
1219 | pub(crate) fn impl_self_ty_recover( | 1236 | pub(crate) fn impl_self_ty_recover( |
@@ -1222,7 +1239,7 @@ pub(crate) fn impl_self_ty_recover( | |||
1222 | impl_id: &ImplId, | 1239 | impl_id: &ImplId, |
1223 | ) -> Binders<Ty> { | 1240 | ) -> Binders<Ty> { |
1224 | let generics = generics(db.upcast(), (*impl_id).into()); | 1241 | let generics = generics(db.upcast(), (*impl_id).into()); |
1225 | Binders::new(generics.len(), Ty::Unknown) | 1242 | Binders::new(generics.len(), TyKind::Unknown.intern(&Interner)) |
1226 | } | 1243 | } |
1227 | 1244 | ||
1228 | pub(crate) fn impl_trait_query(db: &dyn HirDatabase, impl_id: ImplId) -> Option<Binders<TraitRef>> { | 1245 | pub(crate) fn impl_trait_query(db: &dyn HirDatabase, impl_id: ImplId) -> Option<Binders<TraitRef>> { |
@@ -1232,10 +1249,7 @@ pub(crate) fn impl_trait_query(db: &dyn HirDatabase, impl_id: ImplId) -> Option< | |||
1232 | TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable); | 1249 | TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable); |
1233 | let self_ty = db.impl_self_ty(impl_id); | 1250 | let self_ty = db.impl_self_ty(impl_id); |
1234 | let target_trait = impl_data.target_trait.as_ref()?; | 1251 | let target_trait = impl_data.target_trait.as_ref()?; |
1235 | Some(Binders::new( | 1252 | Some(Binders::new(self_ty.num_binders, ctx.lower_trait_ref(target_trait, Some(self_ty.value))?)) |
1236 | self_ty.num_binders, | ||
1237 | TraitRef::from_hir(&ctx, target_trait, Some(self_ty.value))?, | ||
1238 | )) | ||
1239 | } | 1253 | } |
1240 | 1254 | ||
1241 | pub(crate) fn return_type_impl_traits( | 1255 | pub(crate) fn return_type_impl_traits( |
@@ -1248,7 +1262,7 @@ pub(crate) fn return_type_impl_traits( | |||
1248 | let ctx_ret = TyLoweringContext::new(db, &resolver) | 1262 | let ctx_ret = TyLoweringContext::new(db, &resolver) |
1249 | .with_impl_trait_mode(ImplTraitLoweringMode::Opaque) | 1263 | .with_impl_trait_mode(ImplTraitLoweringMode::Opaque) |
1250 | .with_type_param_mode(TypeParamLoweringMode::Variable); | 1264 | .with_type_param_mode(TypeParamLoweringMode::Variable); |
1251 | let _ret = Ty::from_hir(&ctx_ret, &data.ret_type); | 1265 | let _ret = (&ctx_ret).lower_ty(&data.ret_type); |
1252 | let generics = generics(db.upcast(), def.into()); | 1266 | let generics = generics(db.upcast(), def.into()); |
1253 | let num_binders = generics.len(); | 1267 | let num_binders = generics.len(); |
1254 | let return_type_impl_traits = | 1268 | let return_type_impl_traits = |