diff options
Diffstat (limited to 'crates/hir_ty')
-rw-r--r-- | crates/hir_ty/src/autoderef.rs | 12 | ||||
-rw-r--r-- | crates/hir_ty/src/db.rs | 23 | ||||
-rw-r--r-- | crates/hir_ty/src/diagnostics/expr.rs | 21 | ||||
-rw-r--r-- | crates/hir_ty/src/diagnostics/match_check.rs | 8 | ||||
-rw-r--r-- | crates/hir_ty/src/diagnostics/unsafe_check.rs | 6 | ||||
-rw-r--r-- | crates/hir_ty/src/display.rs | 186 | ||||
-rw-r--r-- | crates/hir_ty/src/infer.rs | 70 | ||||
-rw-r--r-- | crates/hir_ty/src/infer/coerce.rs | 38 | ||||
-rw-r--r-- | crates/hir_ty/src/infer/expr.rs | 247 | ||||
-rw-r--r-- | crates/hir_ty/src/infer/pat.rs | 41 | ||||
-rw-r--r-- | crates/hir_ty/src/infer/path.rs | 18 | ||||
-rw-r--r-- | crates/hir_ty/src/infer/unify.rs | 105 | ||||
-rw-r--r-- | crates/hir_ty/src/lib.rs | 381 | ||||
-rw-r--r-- | crates/hir_ty/src/lower.rs | 714 | ||||
-rw-r--r-- | crates/hir_ty/src/method_resolution.rs | 85 | ||||
-rw-r--r-- | crates/hir_ty/src/op.rs | 66 | ||||
-rw-r--r-- | crates/hir_ty/src/traits.rs | 15 | ||||
-rw-r--r-- | crates/hir_ty/src/traits/chalk.rs | 66 | ||||
-rw-r--r-- | crates/hir_ty/src/traits/chalk/interner.rs | 2 | ||||
-rw-r--r-- | crates/hir_ty/src/traits/chalk/mapping.rs | 202 | ||||
-rw-r--r-- | crates/hir_ty/src/traits/chalk/tls.rs | 9 |
21 files changed, 1220 insertions, 1095 deletions
diff --git a/crates/hir_ty/src/autoderef.rs b/crates/hir_ty/src/autoderef.rs index be1fd1f13..d739d5d60 100644 --- a/crates/hir_ty/src/autoderef.rs +++ b/crates/hir_ty/src/autoderef.rs | |||
@@ -12,9 +12,10 @@ use log::{info, warn}; | |||
12 | 12 | ||
13 | use crate::{ | 13 | use crate::{ |
14 | db::HirDatabase, | 14 | db::HirDatabase, |
15 | to_assoc_type_id, | ||
15 | traits::{InEnvironment, Solution}, | 16 | traits::{InEnvironment, Solution}, |
16 | utils::generics, | 17 | utils::generics, |
17 | BoundVar, Canonical, DebruijnIndex, Obligation, Substs, TraitRef, Ty, | 18 | BoundVar, Canonical, DebruijnIndex, Interner, Obligation, Substs, TraitRef, Ty, TyKind, |
18 | }; | 19 | }; |
19 | 20 | ||
20 | const AUTODEREF_RECURSION_LIMIT: usize = 10; | 21 | const AUTODEREF_RECURSION_LIMIT: usize = 10; |
@@ -81,8 +82,9 @@ fn deref_by_trait( | |||
81 | 82 | ||
82 | // Now do the assoc type projection | 83 | // Now do the assoc type projection |
83 | let projection = super::traits::ProjectionPredicate { | 84 | let projection = super::traits::ProjectionPredicate { |
84 | ty: Ty::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, ty.value.kinds.len())), | 85 | ty: TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, ty.value.kinds.len())) |
85 | projection_ty: super::ProjectionTy { associated_ty: target, parameters }, | 86 | .intern(&Interner), |
87 | projection_ty: super::ProjectionTy { associated_ty: to_assoc_type_id(target), parameters }, | ||
86 | }; | 88 | }; |
87 | 89 | ||
88 | let obligation = super::Obligation::Projection(projection); | 90 | let obligation = super::Obligation::Projection(projection); |
@@ -114,8 +116,8 @@ fn deref_by_trait( | |||
114 | // new variables in that case | 116 | // new variables in that case |
115 | 117 | ||
116 | for i in 1..vars.0.kinds.len() { | 118 | for i in 1..vars.0.kinds.len() { |
117 | if vars.0.value[i - 1] | 119 | if vars.0.value[i - 1].interned(&Interner) |
118 | != Ty::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, i - 1)) | 120 | != &TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, i - 1)) |
119 | { | 121 | { |
120 | warn!("complex solution for derefing {:?}: {:?}, ignoring", ty.value, solution); | 122 | warn!("complex solution for derefing {:?}: {:?}, ignoring", ty.value, solution); |
121 | return None; | 123 | return None; |
diff --git a/crates/hir_ty/src/db.rs b/crates/hir_ty/src/db.rs index 06714409f..74a048672 100644 --- a/crates/hir_ty/src/db.rs +++ b/crates/hir_ty/src/db.rs | |||
@@ -12,7 +12,7 @@ use la_arena::ArenaMap; | |||
12 | use crate::{ | 12 | use crate::{ |
13 | method_resolution::{InherentImpls, TraitImpls}, | 13 | method_resolution::{InherentImpls, TraitImpls}, |
14 | traits::chalk, | 14 | traits::chalk, |
15 | Binders, CallableDefId, GenericPredicate, InferenceResult, OpaqueTyId, PolyFnSig, | 15 | Binders, CallableDefId, FnDefId, GenericPredicate, ImplTraitId, InferenceResult, PolyFnSig, |
16 | ReturnTypeImplTraits, TraitRef, Ty, TyDefId, ValueTyDefId, | 16 | ReturnTypeImplTraits, TraitRef, Ty, TyDefId, ValueTyDefId, |
17 | }; | 17 | }; |
18 | use hir_expand::name::Name; | 18 | use hir_expand::name::Name; |
@@ -65,6 +65,9 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> { | |||
65 | #[salsa::invoke(crate::lower::generic_predicates_query)] | 65 | #[salsa::invoke(crate::lower::generic_predicates_query)] |
66 | fn generic_predicates(&self, def: GenericDefId) -> Arc<[Binders<GenericPredicate>]>; | 66 | fn generic_predicates(&self, def: GenericDefId) -> Arc<[Binders<GenericPredicate>]>; |
67 | 67 | ||
68 | #[salsa::invoke(crate::lower::trait_environment_query)] | ||
69 | fn trait_environment(&self, def: GenericDefId) -> Arc<crate::TraitEnvironment>; | ||
70 | |||
68 | #[salsa::invoke(crate::lower::generic_defaults_query)] | 71 | #[salsa::invoke(crate::lower::generic_defaults_query)] |
69 | fn generic_defaults(&self, def: GenericDefId) -> Arc<[Binders<Ty>]>; | 72 | fn generic_defaults(&self, def: GenericDefId) -> Arc<[Binders<Ty>]>; |
70 | 73 | ||
@@ -81,11 +84,11 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> { | |||
81 | #[salsa::interned] | 84 | #[salsa::interned] |
82 | fn intern_callable_def(&self, callable_def: CallableDefId) -> InternedCallableDefId; | 85 | fn intern_callable_def(&self, callable_def: CallableDefId) -> InternedCallableDefId; |
83 | #[salsa::interned] | 86 | #[salsa::interned] |
84 | fn intern_type_param_id(&self, param_id: TypeParamId) -> GlobalTypeParamId; | 87 | fn intern_type_param_id(&self, param_id: TypeParamId) -> InternedTypeParamId; |
85 | #[salsa::interned] | 88 | #[salsa::interned] |
86 | fn intern_impl_trait_id(&self, id: OpaqueTyId) -> InternedOpaqueTyId; | 89 | fn intern_impl_trait_id(&self, id: ImplTraitId) -> InternedOpaqueTyId; |
87 | #[salsa::interned] | 90 | #[salsa::interned] |
88 | fn intern_closure(&self, id: (DefWithBodyId, ExprId)) -> ClosureId; | 91 | fn intern_closure(&self, id: (DefWithBodyId, ExprId)) -> InternedClosureId; |
89 | 92 | ||
90 | #[salsa::invoke(chalk::associated_ty_data_query)] | 93 | #[salsa::invoke(chalk::associated_ty_data_query)] |
91 | fn associated_ty_data(&self, id: chalk::AssocTypeId) -> Arc<chalk::AssociatedTyDatum>; | 94 | fn associated_ty_data(&self, id: chalk::AssocTypeId) -> Arc<chalk::AssociatedTyDatum>; |
@@ -100,10 +103,10 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> { | |||
100 | fn impl_datum(&self, krate: CrateId, impl_id: chalk::ImplId) -> Arc<chalk::ImplDatum>; | 103 | fn impl_datum(&self, krate: CrateId, impl_id: chalk::ImplId) -> Arc<chalk::ImplDatum>; |
101 | 104 | ||
102 | #[salsa::invoke(crate::traits::chalk::fn_def_datum_query)] | 105 | #[salsa::invoke(crate::traits::chalk::fn_def_datum_query)] |
103 | fn fn_def_datum(&self, krate: CrateId, fn_def_id: chalk::FnDefId) -> Arc<chalk::FnDefDatum>; | 106 | fn fn_def_datum(&self, krate: CrateId, fn_def_id: FnDefId) -> Arc<chalk::FnDefDatum>; |
104 | 107 | ||
105 | #[salsa::invoke(crate::traits::chalk::fn_def_variance_query)] | 108 | #[salsa::invoke(crate::traits::chalk::fn_def_variance_query)] |
106 | fn fn_def_variance(&self, krate: CrateId, fn_def_id: chalk::FnDefId) -> chalk::Variances; | 109 | fn fn_def_variance(&self, krate: CrateId, fn_def_id: FnDefId) -> chalk::Variances; |
107 | 110 | ||
108 | #[salsa::invoke(crate::traits::chalk::adt_variance_query)] | 111 | #[salsa::invoke(crate::traits::chalk::adt_variance_query)] |
109 | fn adt_variance(&self, krate: CrateId, adt_id: chalk::AdtId) -> chalk::Variances; | 112 | fn adt_variance(&self, krate: CrateId, adt_id: chalk::AdtId) -> chalk::Variances; |
@@ -149,16 +152,16 @@ fn hir_database_is_object_safe() { | |||
149 | } | 152 | } |
150 | 153 | ||
151 | #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] | 154 | #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] |
152 | pub struct GlobalTypeParamId(salsa::InternId); | 155 | pub struct InternedTypeParamId(salsa::InternId); |
153 | impl_intern_key!(GlobalTypeParamId); | 156 | impl_intern_key!(InternedTypeParamId); |
154 | 157 | ||
155 | #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] | 158 | #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] |
156 | pub struct InternedOpaqueTyId(salsa::InternId); | 159 | pub struct InternedOpaqueTyId(salsa::InternId); |
157 | impl_intern_key!(InternedOpaqueTyId); | 160 | impl_intern_key!(InternedOpaqueTyId); |
158 | 161 | ||
159 | #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] | 162 | #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] |
160 | pub struct ClosureId(salsa::InternId); | 163 | pub struct InternedClosureId(salsa::InternId); |
161 | impl_intern_key!(ClosureId); | 164 | impl_intern_key!(InternedClosureId); |
162 | 165 | ||
163 | /// This exists just for Chalk, because Chalk just has a single `FnDefId` where | 166 | /// This exists just for Chalk, because Chalk just has a single `FnDefId` where |
164 | /// we have different IDs for struct and enum variant constructors. | 167 | /// we have different IDs for struct and enum variant constructors. |
diff --git a/crates/hir_ty/src/diagnostics/expr.rs b/crates/hir_ty/src/diagnostics/expr.rs index 2751cd304..b2bfd68d4 100644 --- a/crates/hir_ty/src/diagnostics/expr.rs +++ b/crates/hir_ty/src/diagnostics/expr.rs | |||
@@ -15,7 +15,7 @@ use crate::{ | |||
15 | MissingPatFields, RemoveThisSemicolon, | 15 | MissingPatFields, RemoveThisSemicolon, |
16 | }, | 16 | }, |
17 | utils::variant_data, | 17 | utils::variant_data, |
18 | AdtId, InferenceResult, Ty, | 18 | AdtId, InferenceResult, Interner, Ty, TyKind, |
19 | }; | 19 | }; |
20 | 20 | ||
21 | pub(crate) use hir_def::{ | 21 | pub(crate) use hir_def::{ |
@@ -289,11 +289,10 @@ impl<'a, 'b> ExprValidator<'a, 'b> { | |||
289 | let (body, source_map): (Arc<Body>, Arc<BodySourceMap>) = | 289 | let (body, source_map): (Arc<Body>, Arc<BodySourceMap>) = |
290 | db.body_with_source_map(self.owner.into()); | 290 | db.body_with_source_map(self.owner.into()); |
291 | 291 | ||
292 | let match_expr_ty = match infer.type_of_expr.get(match_expr) { | 292 | let match_expr_ty = if infer.type_of_expr[match_expr].is_unknown() { |
293 | // If we can't resolve the type of the match expression | 293 | return; |
294 | // we cannot perform exhaustiveness checks. | 294 | } else { |
295 | None | Some(Ty::Unknown) => return, | 295 | &infer.type_of_expr[match_expr] |
296 | Some(ty) => ty, | ||
297 | }; | 296 | }; |
298 | 297 | ||
299 | let cx = MatchCheckCtx { match_expr, body, infer: infer.clone(), db }; | 298 | let cx = MatchCheckCtx { match_expr, body, infer: infer.clone(), db }; |
@@ -379,14 +378,14 @@ impl<'a, 'b> ExprValidator<'a, 'b> { | |||
379 | _ => return, | 378 | _ => return, |
380 | }; | 379 | }; |
381 | 380 | ||
382 | let (params, required) = match mismatch.expected { | 381 | let (params, required) = match mismatch.expected.interned(&Interner) { |
383 | Ty::Adt(AdtId(hir_def::AdtId::EnumId(enum_id)), ref parameters) | 382 | TyKind::Adt(AdtId(hir_def::AdtId::EnumId(enum_id)), ref parameters) |
384 | if enum_id == core_result_enum => | 383 | if *enum_id == core_result_enum => |
385 | { | 384 | { |
386 | (parameters, "Ok".to_string()) | 385 | (parameters, "Ok".to_string()) |
387 | } | 386 | } |
388 | Ty::Adt(AdtId(hir_def::AdtId::EnumId(enum_id)), ref parameters) | 387 | TyKind::Adt(AdtId(hir_def::AdtId::EnumId(enum_id)), ref parameters) |
389 | if enum_id == core_option_enum => | 388 | if *enum_id == core_option_enum => |
390 | { | 389 | { |
391 | (parameters, "Some".to_string()) | 390 | (parameters, "Some".to_string()) |
392 | } | 391 | } |
diff --git a/crates/hir_ty/src/diagnostics/match_check.rs b/crates/hir_ty/src/diagnostics/match_check.rs index 04d39c571..5a5cdcbf3 100644 --- a/crates/hir_ty/src/diagnostics/match_check.rs +++ b/crates/hir_ty/src/diagnostics/match_check.rs | |||
@@ -227,7 +227,7 @@ use hir_def::{ | |||
227 | use la_arena::Idx; | 227 | use la_arena::Idx; |
228 | use smallvec::{smallvec, SmallVec}; | 228 | use smallvec::{smallvec, SmallVec}; |
229 | 229 | ||
230 | use crate::{db::HirDatabase, AdtId, InferenceResult, Ty}; | 230 | use crate::{db::HirDatabase, AdtId, InferenceResult, Interner, TyKind}; |
231 | 231 | ||
232 | #[derive(Debug, Clone, Copy)] | 232 | #[derive(Debug, Clone, Copy)] |
233 | /// Either a pattern from the source code being analyzed, represented as | 233 | /// Either a pattern from the source code being analyzed, represented as |
@@ -626,13 +626,13 @@ pub(super) fn is_useful( | |||
626 | // - enum with no variants | 626 | // - enum with no variants |
627 | // - `!` type | 627 | // - `!` type |
628 | // In those cases, no match arm is useful. | 628 | // In those cases, no match arm is useful. |
629 | match cx.infer[cx.match_expr].strip_references() { | 629 | match cx.infer[cx.match_expr].strip_references().interned(&Interner) { |
630 | Ty::Adt(AdtId(hir_def::AdtId::EnumId(enum_id)), ..) => { | 630 | TyKind::Adt(AdtId(hir_def::AdtId::EnumId(enum_id)), ..) => { |
631 | if cx.db.enum_data(*enum_id).variants.is_empty() { | 631 | if cx.db.enum_data(*enum_id).variants.is_empty() { |
632 | return Ok(Usefulness::NotUseful); | 632 | return Ok(Usefulness::NotUseful); |
633 | } | 633 | } |
634 | } | 634 | } |
635 | Ty::Never => return Ok(Usefulness::NotUseful), | 635 | TyKind::Never => return Ok(Usefulness::NotUseful), |
636 | _ => (), | 636 | _ => (), |
637 | } | 637 | } |
638 | 638 | ||
diff --git a/crates/hir_ty/src/diagnostics/unsafe_check.rs b/crates/hir_ty/src/diagnostics/unsafe_check.rs index e77a20fea..20bb64827 100644 --- a/crates/hir_ty/src/diagnostics/unsafe_check.rs +++ b/crates/hir_ty/src/diagnostics/unsafe_check.rs | |||
@@ -11,7 +11,7 @@ use hir_def::{ | |||
11 | }; | 11 | }; |
12 | use hir_expand::diagnostics::DiagnosticSink; | 12 | use hir_expand::diagnostics::DiagnosticSink; |
13 | 13 | ||
14 | use crate::{db::HirDatabase, diagnostics::MissingUnsafe, InferenceResult, Ty}; | 14 | use crate::{db::HirDatabase, diagnostics::MissingUnsafe, InferenceResult, Interner, TyKind}; |
15 | 15 | ||
16 | pub(super) struct UnsafeValidator<'a, 'b: 'a> { | 16 | pub(super) struct UnsafeValidator<'a, 'b: 'a> { |
17 | owner: DefWithBodyId, | 17 | owner: DefWithBodyId, |
@@ -85,7 +85,7 @@ fn walk_unsafe( | |||
85 | let expr = &body.exprs[current]; | 85 | let expr = &body.exprs[current]; |
86 | match expr { | 86 | match expr { |
87 | &Expr::Call { callee, .. } => { | 87 | &Expr::Call { callee, .. } => { |
88 | if let Some(func) = infer[callee].as_fn_def() { | 88 | if let Some(func) = infer[callee].as_fn_def(db) { |
89 | if db.function_data(func).is_unsafe { | 89 | if db.function_data(func).is_unsafe { |
90 | unsafe_exprs.push(UnsafeExpr { expr: current, inside_unsafe_block }); | 90 | unsafe_exprs.push(UnsafeExpr { expr: current, inside_unsafe_block }); |
91 | } | 91 | } |
@@ -110,7 +110,7 @@ fn walk_unsafe( | |||
110 | } | 110 | } |
111 | } | 111 | } |
112 | Expr::UnaryOp { expr, op: UnaryOp::Deref } => { | 112 | Expr::UnaryOp { expr, op: UnaryOp::Deref } => { |
113 | if let Ty::Raw(..) = &infer[*expr] { | 113 | if let TyKind::Raw(..) = &infer[*expr].interned(&Interner) { |
114 | unsafe_exprs.push(UnsafeExpr { expr: current, inside_unsafe_block }); | 114 | unsafe_exprs.push(UnsafeExpr { expr: current, inside_unsafe_block }); |
115 | } | 115 | } |
116 | } | 116 | } |
diff --git a/crates/hir_ty/src/display.rs b/crates/hir_ty/src/display.rs index ab51cb0a6..e6473586b 100644 --- a/crates/hir_ty/src/display.rs +++ b/crates/hir_ty/src/display.rs | |||
@@ -11,9 +11,10 @@ use hir_def::{ | |||
11 | use hir_expand::name::Name; | 11 | use hir_expand::name::Name; |
12 | 12 | ||
13 | use crate::{ | 13 | use crate::{ |
14 | db::HirDatabase, primitive, utils::generics, AdtId, AliasTy, CallableDefId, CallableSig, | 14 | db::HirDatabase, from_assoc_type_id, from_foreign_def_id, from_placeholder_idx, primitive, |
15 | GenericPredicate, Lifetime, Obligation, OpaqueTy, OpaqueTyId, ProjectionTy, Scalar, Substs, | 15 | to_assoc_type_id, traits::chalk::from_chalk, utils::generics, AdtId, AliasTy, CallableDefId, |
16 | TraitRef, Ty, | 16 | CallableSig, GenericPredicate, ImplTraitId, Interner, Lifetime, Obligation, OpaqueTy, |
17 | ProjectionTy, Scalar, Substs, TraitRef, Ty, TyKind, | ||
17 | }; | 18 | }; |
18 | 19 | ||
19 | pub struct HirFormatter<'a> { | 20 | pub struct HirFormatter<'a> { |
@@ -256,7 +257,7 @@ impl HirDisplay for ProjectionTy { | |||
256 | f.write_joined(&self.parameters[1..], ", ")?; | 257 | f.write_joined(&self.parameters[1..], ", ")?; |
257 | write!(f, ">")?; | 258 | write!(f, ">")?; |
258 | } | 259 | } |
259 | write!(f, ">::{}", f.db.type_alias_data(self.associated_ty).name)?; | 260 | write!(f, ">::{}", f.db.type_alias_data(from_assoc_type_id(self.associated_ty)).name)?; |
260 | Ok(()) | 261 | Ok(()) |
261 | } | 262 | } |
262 | } | 263 | } |
@@ -267,32 +268,32 @@ impl HirDisplay for Ty { | |||
267 | return write!(f, "{}", TYPE_HINT_TRUNCATION); | 268 | return write!(f, "{}", TYPE_HINT_TRUNCATION); |
268 | } | 269 | } |
269 | 270 | ||
270 | match self { | 271 | match self.interned(&Interner) { |
271 | Ty::Never => write!(f, "!")?, | 272 | TyKind::Never => write!(f, "!")?, |
272 | Ty::Str => write!(f, "str")?, | 273 | TyKind::Str => write!(f, "str")?, |
273 | Ty::Scalar(Scalar::Bool) => write!(f, "bool")?, | 274 | TyKind::Scalar(Scalar::Bool) => write!(f, "bool")?, |
274 | Ty::Scalar(Scalar::Char) => write!(f, "char")?, | 275 | TyKind::Scalar(Scalar::Char) => write!(f, "char")?, |
275 | &Ty::Scalar(Scalar::Float(t)) => write!(f, "{}", primitive::float_ty_to_string(t))?, | 276 | &TyKind::Scalar(Scalar::Float(t)) => write!(f, "{}", primitive::float_ty_to_string(t))?, |
276 | &Ty::Scalar(Scalar::Int(t)) => write!(f, "{}", primitive::int_ty_to_string(t))?, | 277 | &TyKind::Scalar(Scalar::Int(t)) => write!(f, "{}", primitive::int_ty_to_string(t))?, |
277 | &Ty::Scalar(Scalar::Uint(t)) => write!(f, "{}", primitive::uint_ty_to_string(t))?, | 278 | &TyKind::Scalar(Scalar::Uint(t)) => write!(f, "{}", primitive::uint_ty_to_string(t))?, |
278 | Ty::Slice(parameters) => { | 279 | TyKind::Slice(parameters) => { |
279 | let t = parameters.as_single(); | 280 | let t = parameters.as_single(); |
280 | write!(f, "[")?; | 281 | write!(f, "[")?; |
281 | t.hir_fmt(f)?; | 282 | t.hir_fmt(f)?; |
282 | write!(f, "]")?; | 283 | write!(f, "]")?; |
283 | } | 284 | } |
284 | Ty::Array(parameters) => { | 285 | TyKind::Array(parameters) => { |
285 | let t = parameters.as_single(); | 286 | let t = parameters.as_single(); |
286 | write!(f, "[")?; | 287 | write!(f, "[")?; |
287 | t.hir_fmt(f)?; | 288 | t.hir_fmt(f)?; |
288 | write!(f, "; _]")?; | 289 | write!(f, "; _]")?; |
289 | } | 290 | } |
290 | Ty::Raw(m, parameters) | Ty::Ref(m, parameters) => { | 291 | TyKind::Raw(m, parameters) | TyKind::Ref(m, parameters) => { |
291 | let t = parameters.as_single(); | 292 | let t = parameters.as_single(); |
292 | let ty_display = | 293 | let ty_display = |
293 | t.into_displayable(f.db, f.max_size, f.omit_verbose_types, f.display_target); | 294 | t.into_displayable(f.db, f.max_size, f.omit_verbose_types, f.display_target); |
294 | 295 | ||
295 | if matches!(self, Ty::Raw(..)) { | 296 | if matches!(self.interned(&Interner), TyKind::Raw(..)) { |
296 | write!( | 297 | write!( |
297 | f, | 298 | f, |
298 | "*{}", | 299 | "*{}", |
@@ -312,22 +313,26 @@ impl HirDisplay for Ty { | |||
312 | )?; | 313 | )?; |
313 | } | 314 | } |
314 | 315 | ||
316 | // FIXME: all this just to decide whether to use parentheses... | ||
315 | let datas; | 317 | let datas; |
316 | let predicates = match t { | 318 | let predicates = match t.interned(&Interner) { |
317 | Ty::Dyn(predicates) if predicates.len() > 1 => { | 319 | TyKind::Dyn(predicates) if predicates.len() > 1 => { |
318 | Cow::Borrowed(predicates.as_ref()) | 320 | Cow::Borrowed(predicates.as_ref()) |
319 | } | 321 | } |
320 | &Ty::Alias(AliasTy::Opaque(OpaqueTy { | 322 | &TyKind::Alias(AliasTy::Opaque(OpaqueTy { opaque_ty_id, ref parameters })) => { |
321 | opaque_ty_id: OpaqueTyId::ReturnTypeImplTrait(func, idx), | 323 | let impl_trait_id = f.db.lookup_intern_impl_trait_id(opaque_ty_id.into()); |
322 | ref parameters, | 324 | if let ImplTraitId::ReturnTypeImplTrait(func, idx) = impl_trait_id { |
323 | })) => { | 325 | datas = |
324 | datas = | 326 | f.db.return_type_impl_traits(func) |
325 | f.db.return_type_impl_traits(func).expect("impl trait id without data"); | 327 | .expect("impl trait id without data"); |
326 | let data = (*datas) | 328 | let data = (*datas) |
327 | .as_ref() | 329 | .as_ref() |
328 | .map(|rpit| rpit.impl_traits[idx as usize].bounds.clone()); | 330 | .map(|rpit| rpit.impl_traits[idx as usize].bounds.clone()); |
329 | let bounds = data.subst(parameters); | 331 | let bounds = data.subst(parameters); |
330 | Cow::Owned(bounds.value) | 332 | Cow::Owned(bounds.value) |
333 | } else { | ||
334 | Cow::Borrowed(&[][..]) | ||
335 | } | ||
331 | } | 336 | } |
332 | _ => Cow::Borrowed(&[][..]), | 337 | _ => Cow::Borrowed(&[][..]), |
333 | }; | 338 | }; |
@@ -347,7 +352,7 @@ impl HirDisplay for Ty { | |||
347 | write!(f, "{}", ty_display)?; | 352 | write!(f, "{}", ty_display)?; |
348 | } | 353 | } |
349 | } | 354 | } |
350 | Ty::Tuple(_, substs) => { | 355 | TyKind::Tuple(_, substs) => { |
351 | if substs.len() == 1 { | 356 | if substs.len() == 1 { |
352 | write!(f, "(")?; | 357 | write!(f, "(")?; |
353 | substs[0].hir_fmt(f)?; | 358 | substs[0].hir_fmt(f)?; |
@@ -358,12 +363,12 @@ impl HirDisplay for Ty { | |||
358 | write!(f, ")")?; | 363 | write!(f, ")")?; |
359 | } | 364 | } |
360 | } | 365 | } |
361 | Ty::Function(fn_ptr) => { | 366 | TyKind::Function(fn_ptr) => { |
362 | let sig = CallableSig::from_fn_ptr(fn_ptr); | 367 | let sig = CallableSig::from_fn_ptr(fn_ptr); |
363 | sig.hir_fmt(f)?; | 368 | sig.hir_fmt(f)?; |
364 | } | 369 | } |
365 | Ty::FnDef(def, parameters) => { | 370 | TyKind::FnDef(def, parameters) => { |
366 | let def = *def; | 371 | let def = from_chalk(f.db, *def); |
367 | let sig = f.db.callable_item_signature(def).subst(parameters); | 372 | let sig = f.db.callable_item_signature(def).subst(parameters); |
368 | match def { | 373 | match def { |
369 | CallableDefId::FunctionId(ff) => { | 374 | CallableDefId::FunctionId(ff) => { |
@@ -401,7 +406,7 @@ impl HirDisplay for Ty { | |||
401 | write!(f, " -> {}", ret_display)?; | 406 | write!(f, " -> {}", ret_display)?; |
402 | } | 407 | } |
403 | } | 408 | } |
404 | Ty::Adt(AdtId(def_id), parameters) => { | 409 | TyKind::Adt(AdtId(def_id), parameters) => { |
405 | match f.display_target { | 410 | match f.display_target { |
406 | DisplayTarget::Diagnostics | DisplayTarget::Test => { | 411 | DisplayTarget::Diagnostics | DisplayTarget::Test => { |
407 | let name = match *def_id { | 412 | let name = match *def_id { |
@@ -427,37 +432,39 @@ impl HirDisplay for Ty { | |||
427 | } | 432 | } |
428 | 433 | ||
429 | if parameters.len() > 0 { | 434 | if parameters.len() > 0 { |
430 | let parameters_to_write = | 435 | let parameters_to_write = if f.display_target.is_source_code() |
431 | if f.display_target.is_source_code() || f.omit_verbose_types() { | 436 | || f.omit_verbose_types() |
432 | match self | 437 | { |
433 | .as_generic_def() | 438 | match self |
434 | .map(|generic_def_id| f.db.generic_defaults(generic_def_id)) | 439 | .as_generic_def(f.db) |
435 | .filter(|defaults| !defaults.is_empty()) | 440 | .map(|generic_def_id| f.db.generic_defaults(generic_def_id)) |
436 | { | 441 | .filter(|defaults| !defaults.is_empty()) |
437 | None => parameters.0.as_ref(), | 442 | { |
438 | Some(default_parameters) => { | 443 | None => parameters.0.as_ref(), |
439 | let mut default_from = 0; | 444 | Some(default_parameters) => { |
440 | for (i, parameter) in parameters.iter().enumerate() { | 445 | let mut default_from = 0; |
441 | match (parameter, default_parameters.get(i)) { | 446 | for (i, parameter) in parameters.iter().enumerate() { |
442 | (&Ty::Unknown, _) | (_, None) => { | 447 | match (parameter.interned(&Interner), default_parameters.get(i)) |
448 | { | ||
449 | (&TyKind::Unknown, _) | (_, None) => { | ||
450 | default_from = i + 1; | ||
451 | } | ||
452 | (_, Some(default_parameter)) => { | ||
453 | let actual_default = default_parameter | ||
454 | .clone() | ||
455 | .subst(¶meters.prefix(i)); | ||
456 | if parameter != &actual_default { | ||
443 | default_from = i + 1; | 457 | default_from = i + 1; |
444 | } | 458 | } |
445 | (_, Some(default_parameter)) => { | ||
446 | let actual_default = default_parameter | ||
447 | .clone() | ||
448 | .subst(¶meters.prefix(i)); | ||
449 | if parameter != &actual_default { | ||
450 | default_from = i + 1; | ||
451 | } | ||
452 | } | ||
453 | } | 459 | } |
454 | } | 460 | } |
455 | ¶meters.0[0..default_from] | ||
456 | } | 461 | } |
462 | ¶meters.0[0..default_from] | ||
457 | } | 463 | } |
458 | } else { | 464 | } |
459 | parameters.0.as_ref() | 465 | } else { |
460 | }; | 466 | parameters.0.as_ref() |
467 | }; | ||
461 | if !parameters_to_write.is_empty() { | 468 | if !parameters_to_write.is_empty() { |
462 | write!(f, "<")?; | 469 | write!(f, "<")?; |
463 | f.write_joined(parameters_to_write, ", ")?; | 470 | f.write_joined(parameters_to_write, ", ")?; |
@@ -465,13 +472,14 @@ impl HirDisplay for Ty { | |||
465 | } | 472 | } |
466 | } | 473 | } |
467 | } | 474 | } |
468 | Ty::AssociatedType(type_alias, parameters) => { | 475 | TyKind::AssociatedType(assoc_type_id, parameters) => { |
476 | let type_alias = from_assoc_type_id(*assoc_type_id); | ||
469 | let trait_ = match type_alias.lookup(f.db.upcast()).container { | 477 | let trait_ = match type_alias.lookup(f.db.upcast()).container { |
470 | AssocContainerId::TraitId(it) => it, | 478 | AssocContainerId::TraitId(it) => it, |
471 | _ => panic!("not an associated type"), | 479 | _ => panic!("not an associated type"), |
472 | }; | 480 | }; |
473 | let trait_ = f.db.trait_data(trait_); | 481 | let trait_ = f.db.trait_data(trait_); |
474 | let type_alias_data = f.db.type_alias_data(*type_alias); | 482 | let type_alias_data = f.db.type_alias_data(type_alias); |
475 | 483 | ||
476 | // Use placeholder associated types when the target is test (https://rust-lang.github.io/chalk/book/clauses/type_equality.html#placeholder-associated-types) | 484 | // Use placeholder associated types when the target is test (https://rust-lang.github.io/chalk/book/clauses/type_equality.html#placeholder-associated-types) |
477 | if f.display_target.is_test() { | 485 | if f.display_target.is_test() { |
@@ -482,19 +490,22 @@ impl HirDisplay for Ty { | |||
482 | write!(f, ">")?; | 490 | write!(f, ">")?; |
483 | } | 491 | } |
484 | } else { | 492 | } else { |
485 | let projection_ty = | 493 | let projection_ty = ProjectionTy { |
486 | ProjectionTy { associated_ty: *type_alias, parameters: parameters.clone() }; | 494 | associated_ty: to_assoc_type_id(type_alias), |
495 | parameters: parameters.clone(), | ||
496 | }; | ||
487 | 497 | ||
488 | projection_ty.hir_fmt(f)?; | 498 | projection_ty.hir_fmt(f)?; |
489 | } | 499 | } |
490 | } | 500 | } |
491 | Ty::ForeignType(type_alias) => { | 501 | TyKind::ForeignType(type_alias) => { |
492 | let type_alias = f.db.type_alias_data(*type_alias); | 502 | let type_alias = f.db.type_alias_data(from_foreign_def_id(*type_alias)); |
493 | write!(f, "{}", type_alias.name)?; | 503 | write!(f, "{}", type_alias.name)?; |
494 | } | 504 | } |
495 | Ty::OpaqueType(opaque_ty_id, parameters) => { | 505 | TyKind::OpaqueType(opaque_ty_id, parameters) => { |
496 | match opaque_ty_id { | 506 | let impl_trait_id = f.db.lookup_intern_impl_trait_id((*opaque_ty_id).into()); |
497 | &OpaqueTyId::ReturnTypeImplTrait(func, idx) => { | 507 | match impl_trait_id { |
508 | ImplTraitId::ReturnTypeImplTrait(func, idx) => { | ||
498 | let datas = | 509 | let datas = |
499 | f.db.return_type_impl_traits(func).expect("impl trait id without data"); | 510 | f.db.return_type_impl_traits(func).expect("impl trait id without data"); |
500 | let data = (*datas) | 511 | let data = (*datas) |
@@ -504,14 +515,14 @@ impl HirDisplay for Ty { | |||
504 | write_bounds_like_dyn_trait_with_prefix("impl", &bounds.value, f)?; | 515 | write_bounds_like_dyn_trait_with_prefix("impl", &bounds.value, f)?; |
505 | // FIXME: it would maybe be good to distinguish this from the alias type (when debug printing), and to show the substitution | 516 | // FIXME: it would maybe be good to distinguish this from the alias type (when debug printing), and to show the substitution |
506 | } | 517 | } |
507 | OpaqueTyId::AsyncBlockTypeImplTrait(..) => { | 518 | ImplTraitId::AsyncBlockTypeImplTrait(..) => { |
508 | write!(f, "impl Future<Output = ")?; | 519 | write!(f, "impl Future<Output = ")?; |
509 | parameters[0].hir_fmt(f)?; | 520 | parameters[0].hir_fmt(f)?; |
510 | write!(f, ">")?; | 521 | write!(f, ">")?; |
511 | } | 522 | } |
512 | } | 523 | } |
513 | } | 524 | } |
514 | Ty::Closure(.., substs) => { | 525 | TyKind::Closure(.., substs) => { |
515 | let sig = substs[0].callable_sig(f.db); | 526 | let sig = substs[0].callable_sig(f.db); |
516 | if let Some(sig) = sig { | 527 | if let Some(sig) = sig { |
517 | if sig.params().is_empty() { | 528 | if sig.params().is_empty() { |
@@ -535,7 +546,8 @@ impl HirDisplay for Ty { | |||
535 | write!(f, "{{closure}}")?; | 546 | write!(f, "{{closure}}")?; |
536 | } | 547 | } |
537 | } | 548 | } |
538 | Ty::Placeholder(id) => { | 549 | TyKind::Placeholder(idx) => { |
550 | let id = from_placeholder_idx(f.db, *idx); | ||
539 | let generics = generics(f.db.upcast(), id.parent); | 551 | let generics = generics(f.db.upcast(), id.parent); |
540 | let param_data = &generics.params.types[id.local_id]; | 552 | let param_data = &generics.params.types[id.local_id]; |
541 | match param_data.provenance { | 553 | match param_data.provenance { |
@@ -543,8 +555,8 @@ impl HirDisplay for Ty { | |||
543 | write!(f, "{}", param_data.name.clone().unwrap_or_else(Name::missing))? | 555 | write!(f, "{}", param_data.name.clone().unwrap_or_else(Name::missing))? |
544 | } | 556 | } |
545 | TypeParamProvenance::ArgumentImplTrait => { | 557 | TypeParamProvenance::ArgumentImplTrait => { |
546 | let bounds = f.db.generic_predicates_for_param(*id); | 558 | let bounds = f.db.generic_predicates_for_param(id); |
547 | let substs = Substs::type_params_for_generics(&generics); | 559 | let substs = Substs::type_params_for_generics(f.db, &generics); |
548 | write_bounds_like_dyn_trait_with_prefix( | 560 | write_bounds_like_dyn_trait_with_prefix( |
549 | "impl", | 561 | "impl", |
550 | &bounds.iter().map(|b| b.clone().subst(&substs)).collect::<Vec<_>>(), | 562 | &bounds.iter().map(|b| b.clone().subst(&substs)).collect::<Vec<_>>(), |
@@ -553,14 +565,15 @@ impl HirDisplay for Ty { | |||
553 | } | 565 | } |
554 | } | 566 | } |
555 | } | 567 | } |
556 | Ty::BoundVar(idx) => write!(f, "?{}.{}", idx.debruijn.depth(), idx.index)?, | 568 | TyKind::BoundVar(idx) => write!(f, "?{}.{}", idx.debruijn.depth(), idx.index)?, |
557 | Ty::Dyn(predicates) => { | 569 | TyKind::Dyn(predicates) => { |
558 | write_bounds_like_dyn_trait_with_prefix("dyn", predicates, f)?; | 570 | write_bounds_like_dyn_trait_with_prefix("dyn", predicates, f)?; |
559 | } | 571 | } |
560 | Ty::Alias(AliasTy::Projection(p_ty)) => p_ty.hir_fmt(f)?, | 572 | TyKind::Alias(AliasTy::Projection(p_ty)) => p_ty.hir_fmt(f)?, |
561 | Ty::Alias(AliasTy::Opaque(opaque_ty)) => { | 573 | TyKind::Alias(AliasTy::Opaque(opaque_ty)) => { |
562 | match opaque_ty.opaque_ty_id { | 574 | let impl_trait_id = f.db.lookup_intern_impl_trait_id(opaque_ty.opaque_ty_id.into()); |
563 | OpaqueTyId::ReturnTypeImplTrait(func, idx) => { | 575 | match impl_trait_id { |
576 | ImplTraitId::ReturnTypeImplTrait(func, idx) => { | ||
564 | let datas = | 577 | let datas = |
565 | f.db.return_type_impl_traits(func).expect("impl trait id without data"); | 578 | f.db.return_type_impl_traits(func).expect("impl trait id without data"); |
566 | let data = (*datas) | 579 | let data = (*datas) |
@@ -569,12 +582,12 @@ impl HirDisplay for Ty { | |||
569 | let bounds = data.subst(&opaque_ty.parameters); | 582 | let bounds = data.subst(&opaque_ty.parameters); |
570 | write_bounds_like_dyn_trait_with_prefix("impl", &bounds.value, f)?; | 583 | write_bounds_like_dyn_trait_with_prefix("impl", &bounds.value, f)?; |
571 | } | 584 | } |
572 | OpaqueTyId::AsyncBlockTypeImplTrait(..) => { | 585 | ImplTraitId::AsyncBlockTypeImplTrait(..) => { |
573 | write!(f, "{{async block}}")?; | 586 | write!(f, "{{async block}}")?; |
574 | } | 587 | } |
575 | }; | 588 | }; |
576 | } | 589 | } |
577 | Ty::Unknown => { | 590 | TyKind::Unknown => { |
578 | if f.display_target.is_source_code() { | 591 | if f.display_target.is_source_code() { |
579 | return Err(HirDisplayError::DisplaySourceCodeError( | 592 | return Err(HirDisplayError::DisplaySourceCodeError( |
580 | DisplaySourceCodeError::UnknownType, | 593 | DisplaySourceCodeError::UnknownType, |
@@ -582,7 +595,7 @@ impl HirDisplay for Ty { | |||
582 | } | 595 | } |
583 | write!(f, "{{unknown}}")?; | 596 | write!(f, "{{unknown}}")?; |
584 | } | 597 | } |
585 | Ty::InferenceVar(..) => write!(f, "_")?, | 598 | TyKind::InferenceVar(..) => write!(f, "_")?, |
586 | } | 599 | } |
587 | Ok(()) | 600 | Ok(()) |
588 | } | 601 | } |
@@ -695,7 +708,9 @@ fn write_bounds_like_dyn_trait( | |||
695 | write!(f, "<")?; | 708 | write!(f, "<")?; |
696 | angle_open = true; | 709 | angle_open = true; |
697 | } | 710 | } |
698 | let type_alias = f.db.type_alias_data(projection_pred.projection_ty.associated_ty); | 711 | let type_alias = f.db.type_alias_data(from_assoc_type_id( |
712 | projection_pred.projection_ty.associated_ty, | ||
713 | )); | ||
699 | write!(f, "{} = ", type_alias.name)?; | 714 | write!(f, "{} = ", type_alias.name)?; |
700 | projection_pred.ty.hir_fmt(f)?; | 715 | projection_pred.ty.hir_fmt(f)?; |
701 | } | 716 | } |
@@ -766,7 +781,10 @@ impl HirDisplay for GenericPredicate { | |||
766 | write!( | 781 | write!( |
767 | f, | 782 | f, |
768 | ">::{} = ", | 783 | ">::{} = ", |
769 | f.db.type_alias_data(projection_pred.projection_ty.associated_ty).name, | 784 | f.db.type_alias_data(from_assoc_type_id( |
785 | projection_pred.projection_ty.associated_ty | ||
786 | )) | ||
787 | .name, | ||
770 | )?; | 788 | )?; |
771 | projection_pred.ty.hir_fmt(f)?; | 789 | projection_pred.ty.hir_fmt(f)?; |
772 | } | 790 | } |
diff --git a/crates/hir_ty/src/infer.rs b/crates/hir_ty/src/infer.rs index 4d771a91e..8cf59821f 100644 --- a/crates/hir_ty/src/infer.rs +++ b/crates/hir_ty/src/infer.rs | |||
@@ -41,7 +41,8 @@ use super::{ | |||
41 | InEnvironment, ProjectionTy, Substs, TraitEnvironment, TraitRef, Ty, TypeWalk, | 41 | InEnvironment, ProjectionTy, Substs, TraitEnvironment, TraitRef, Ty, TypeWalk, |
42 | }; | 42 | }; |
43 | use crate::{ | 43 | use crate::{ |
44 | db::HirDatabase, infer::diagnostics::InferenceDiagnostic, lower::ImplTraitLoweringMode, AliasTy, | 44 | db::HirDatabase, infer::diagnostics::InferenceDiagnostic, lower::ImplTraitLoweringMode, |
45 | to_assoc_type_id, AliasTy, Interner, TyKind, | ||
45 | }; | 46 | }; |
46 | 47 | ||
47 | pub(crate) use unify::unify; | 48 | pub(crate) use unify::unify; |
@@ -169,7 +170,7 @@ impl Index<ExprId> for InferenceResult { | |||
169 | type Output = Ty; | 170 | type Output = Ty; |
170 | 171 | ||
171 | fn index(&self, expr: ExprId) -> &Ty { | 172 | fn index(&self, expr: ExprId) -> &Ty { |
172 | self.type_of_expr.get(expr).unwrap_or(&Ty::Unknown) | 173 | self.type_of_expr.get(expr).unwrap_or(&Ty(TyKind::Unknown)) |
173 | } | 174 | } |
174 | } | 175 | } |
175 | 176 | ||
@@ -177,7 +178,7 @@ impl Index<PatId> for InferenceResult { | |||
177 | type Output = Ty; | 178 | type Output = Ty; |
178 | 179 | ||
179 | fn index(&self, pat: PatId) -> &Ty { | 180 | fn index(&self, pat: PatId) -> &Ty { |
180 | self.type_of_pat.get(pat).unwrap_or(&Ty::Unknown) | 181 | self.type_of_pat.get(pat).unwrap_or(&Ty(TyKind::Unknown)) |
181 | } | 182 | } |
182 | } | 183 | } |
183 | 184 | ||
@@ -226,8 +227,10 @@ impl<'a> InferenceContext<'a> { | |||
226 | result: InferenceResult::default(), | 227 | result: InferenceResult::default(), |
227 | table: unify::InferenceTable::new(), | 228 | table: unify::InferenceTable::new(), |
228 | obligations: Vec::default(), | 229 | obligations: Vec::default(), |
229 | return_ty: Ty::Unknown, // set in collect_fn_signature | 230 | return_ty: TyKind::Unknown.intern(&Interner), // set in collect_fn_signature |
230 | trait_env: TraitEnvironment::lower(db, &resolver), | 231 | trait_env: owner |
232 | .as_generic_def_id() | ||
233 | .map_or_else(Default::default, |d| db.trait_environment(d)), | ||
231 | db, | 234 | db, |
232 | owner, | 235 | owner, |
233 | body: db.body(owner), | 236 | body: db.body(owner), |
@@ -237,15 +240,19 @@ impl<'a> InferenceContext<'a> { | |||
237 | } | 240 | } |
238 | } | 241 | } |
239 | 242 | ||
243 | fn err_ty(&self) -> Ty { | ||
244 | TyKind::Unknown.intern(&Interner) | ||
245 | } | ||
246 | |||
240 | fn resolve_all(mut self) -> InferenceResult { | 247 | fn resolve_all(mut self) -> InferenceResult { |
241 | // FIXME resolve obligations as well (use Guidance if necessary) | 248 | // FIXME resolve obligations as well (use Guidance if necessary) |
242 | let mut result = std::mem::take(&mut self.result); | 249 | let mut result = std::mem::take(&mut self.result); |
243 | for ty in result.type_of_expr.values_mut() { | 250 | for ty in result.type_of_expr.values_mut() { |
244 | let resolved = self.table.resolve_ty_completely(mem::replace(ty, Ty::Unknown)); | 251 | let resolved = self.table.resolve_ty_completely(ty.clone()); |
245 | *ty = resolved; | 252 | *ty = resolved; |
246 | } | 253 | } |
247 | for ty in result.type_of_pat.values_mut() { | 254 | for ty in result.type_of_pat.values_mut() { |
248 | let resolved = self.table.resolve_ty_completely(mem::replace(ty, Ty::Unknown)); | 255 | let resolved = self.table.resolve_ty_completely(ty.clone()); |
249 | *ty = resolved; | 256 | *ty = resolved; |
250 | } | 257 | } |
251 | result | 258 | result |
@@ -287,7 +294,7 @@ impl<'a> InferenceContext<'a> { | |||
287 | // FIXME use right resolver for block | 294 | // FIXME use right resolver for block |
288 | let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver) | 295 | let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver) |
289 | .with_impl_trait_mode(impl_trait_mode); | 296 | .with_impl_trait_mode(impl_trait_mode); |
290 | let ty = Ty::from_hir(&ctx, type_ref); | 297 | let ty = ctx.lower_ty(type_ref); |
291 | let ty = self.insert_type_vars(ty); | 298 | let ty = self.insert_type_vars(ty); |
292 | self.normalize_associated_types_in(ty) | 299 | self.normalize_associated_types_in(ty) |
293 | } | 300 | } |
@@ -298,8 +305,8 @@ impl<'a> InferenceContext<'a> { | |||
298 | 305 | ||
299 | /// Replaces Ty::Unknown by a new type var, so we can maybe still infer it. | 306 | /// Replaces Ty::Unknown by a new type var, so we can maybe still infer it. |
300 | fn insert_type_vars_shallow(&mut self, ty: Ty) -> Ty { | 307 | fn insert_type_vars_shallow(&mut self, ty: Ty) -> Ty { |
301 | match ty { | 308 | match ty.interned(&Interner) { |
302 | Ty::Unknown => self.table.new_type_var(), | 309 | TyKind::Unknown => self.table.new_type_var(), |
303 | _ => ty, | 310 | _ => ty, |
304 | } | 311 | } |
305 | } | 312 | } |
@@ -377,13 +384,16 @@ impl<'a> InferenceContext<'a> { | |||
377 | let trait_ref = TraitRef { trait_, substs: substs.clone() }; | 384 | let trait_ref = TraitRef { trait_, substs: substs.clone() }; |
378 | let projection = ProjectionPredicate { | 385 | let projection = ProjectionPredicate { |
379 | ty: ty.clone(), | 386 | ty: ty.clone(), |
380 | projection_ty: ProjectionTy { associated_ty: res_assoc_ty, parameters: substs }, | 387 | projection_ty: ProjectionTy { |
388 | associated_ty: to_assoc_type_id(res_assoc_ty), | ||
389 | parameters: substs, | ||
390 | }, | ||
381 | }; | 391 | }; |
382 | self.obligations.push(Obligation::Trait(trait_ref)); | 392 | self.obligations.push(Obligation::Trait(trait_ref)); |
383 | self.obligations.push(Obligation::Projection(projection)); | 393 | self.obligations.push(Obligation::Projection(projection)); |
384 | self.resolve_ty_as_possible(ty) | 394 | self.resolve_ty_as_possible(ty) |
385 | } | 395 | } |
386 | None => Ty::Unknown, | 396 | None => self.err_ty(), |
387 | } | 397 | } |
388 | } | 398 | } |
389 | 399 | ||
@@ -395,8 +405,10 @@ impl<'a> InferenceContext<'a> { | |||
395 | /// to do it as well. | 405 | /// to do it as well. |
396 | fn normalize_associated_types_in(&mut self, ty: Ty) -> Ty { | 406 | fn normalize_associated_types_in(&mut self, ty: Ty) -> Ty { |
397 | let ty = self.resolve_ty_as_possible(ty); | 407 | let ty = self.resolve_ty_as_possible(ty); |
398 | ty.fold(&mut |ty| match ty { | 408 | ty.fold(&mut |ty| match ty.interned(&Interner) { |
399 | Ty::Alias(AliasTy::Projection(proj_ty)) => self.normalize_projection_ty(proj_ty), | 409 | TyKind::Alias(AliasTy::Projection(proj_ty)) => { |
410 | self.normalize_projection_ty(proj_ty.clone()) | ||
411 | } | ||
400 | _ => ty, | 412 | _ => ty, |
401 | }) | 413 | }) |
402 | } | 414 | } |
@@ -412,7 +424,7 @@ impl<'a> InferenceContext<'a> { | |||
412 | fn resolve_variant(&mut self, path: Option<&Path>) -> (Ty, Option<VariantId>) { | 424 | fn resolve_variant(&mut self, path: Option<&Path>) -> (Ty, Option<VariantId>) { |
413 | let path = match path { | 425 | let path = match path { |
414 | Some(path) => path, | 426 | Some(path) => path, |
415 | None => return (Ty::Unknown, None), | 427 | None => return (self.err_ty(), None), |
416 | }; | 428 | }; |
417 | let resolver = &self.resolver; | 429 | let resolver = &self.resolver; |
418 | let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver); | 430 | let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver); |
@@ -421,30 +433,30 @@ impl<'a> InferenceContext<'a> { | |||
421 | let (resolution, unresolved) = | 433 | let (resolution, unresolved) = |
422 | match resolver.resolve_path_in_type_ns(self.db.upcast(), path.mod_path()) { | 434 | match resolver.resolve_path_in_type_ns(self.db.upcast(), path.mod_path()) { |
423 | Some(it) => it, | 435 | Some(it) => it, |
424 | None => return (Ty::Unknown, None), | 436 | None => return (self.err_ty(), None), |
425 | }; | 437 | }; |
426 | return match resolution { | 438 | return match resolution { |
427 | TypeNs::AdtId(AdtId::StructId(strukt)) => { | 439 | TypeNs::AdtId(AdtId::StructId(strukt)) => { |
428 | let substs = Ty::substs_from_path(&ctx, path, strukt.into(), true); | 440 | let substs = ctx.substs_from_path(path, strukt.into(), true); |
429 | let ty = self.db.ty(strukt.into()); | 441 | let ty = self.db.ty(strukt.into()); |
430 | let ty = self.insert_type_vars(ty.subst(&substs)); | 442 | let ty = self.insert_type_vars(ty.subst(&substs)); |
431 | forbid_unresolved_segments((ty, Some(strukt.into())), unresolved) | 443 | forbid_unresolved_segments((ty, Some(strukt.into())), unresolved) |
432 | } | 444 | } |
433 | TypeNs::AdtId(AdtId::UnionId(u)) => { | 445 | TypeNs::AdtId(AdtId::UnionId(u)) => { |
434 | let substs = Ty::substs_from_path(&ctx, path, u.into(), true); | 446 | let substs = ctx.substs_from_path(path, u.into(), true); |
435 | let ty = self.db.ty(u.into()); | 447 | let ty = self.db.ty(u.into()); |
436 | let ty = self.insert_type_vars(ty.subst(&substs)); | 448 | let ty = self.insert_type_vars(ty.subst(&substs)); |
437 | forbid_unresolved_segments((ty, Some(u.into())), unresolved) | 449 | forbid_unresolved_segments((ty, Some(u.into())), unresolved) |
438 | } | 450 | } |
439 | TypeNs::EnumVariantId(var) => { | 451 | TypeNs::EnumVariantId(var) => { |
440 | let substs = Ty::substs_from_path(&ctx, path, var.into(), true); | 452 | let substs = ctx.substs_from_path(path, var.into(), true); |
441 | let ty = self.db.ty(var.parent.into()); | 453 | let ty = self.db.ty(var.parent.into()); |
442 | let ty = self.insert_type_vars(ty.subst(&substs)); | 454 | let ty = self.insert_type_vars(ty.subst(&substs)); |
443 | forbid_unresolved_segments((ty, Some(var.into())), unresolved) | 455 | forbid_unresolved_segments((ty, Some(var.into())), unresolved) |
444 | } | 456 | } |
445 | TypeNs::SelfType(impl_id) => { | 457 | TypeNs::SelfType(impl_id) => { |
446 | let generics = crate::utils::generics(self.db.upcast(), impl_id.into()); | 458 | let generics = crate::utils::generics(self.db.upcast(), impl_id.into()); |
447 | let substs = Substs::type_params_for_generics(&generics); | 459 | let substs = Substs::type_params_for_generics(self.db, &generics); |
448 | let ty = self.db.impl_self_ty(impl_id).subst(&substs); | 460 | let ty = self.db.impl_self_ty(impl_id).subst(&substs); |
449 | match unresolved { | 461 | match unresolved { |
450 | None => { | 462 | None => { |
@@ -462,11 +474,11 @@ impl<'a> InferenceContext<'a> { | |||
462 | } | 474 | } |
463 | } | 475 | } |
464 | // FIXME potentially resolve assoc type | 476 | // FIXME potentially resolve assoc type |
465 | (Ty::Unknown, None) | 477 | (self.err_ty(), None) |
466 | } | 478 | } |
467 | Some(_) => { | 479 | Some(_) => { |
468 | // FIXME diagnostic | 480 | // FIXME diagnostic |
469 | (Ty::Unknown, None) | 481 | (self.err_ty(), None) |
470 | } | 482 | } |
471 | } | 483 | } |
472 | } | 484 | } |
@@ -480,15 +492,15 @@ impl<'a> InferenceContext<'a> { | |||
480 | } | 492 | } |
481 | TypeNs::AdtSelfType(_) => { | 493 | TypeNs::AdtSelfType(_) => { |
482 | // FIXME this could happen in array size expressions, once we're checking them | 494 | // FIXME this could happen in array size expressions, once we're checking them |
483 | (Ty::Unknown, None) | 495 | (self.err_ty(), None) |
484 | } | 496 | } |
485 | TypeNs::GenericParam(_) => { | 497 | TypeNs::GenericParam(_) => { |
486 | // FIXME potentially resolve assoc type | 498 | // FIXME potentially resolve assoc type |
487 | (Ty::Unknown, None) | 499 | (self.err_ty(), None) |
488 | } | 500 | } |
489 | TypeNs::AdtId(AdtId::EnumId(_)) | TypeNs::BuiltinType(_) | TypeNs::TraitId(_) => { | 501 | TypeNs::AdtId(AdtId::EnumId(_)) | TypeNs::BuiltinType(_) | TypeNs::TraitId(_) => { |
490 | // FIXME diagnostic | 502 | // FIXME diagnostic |
491 | (Ty::Unknown, None) | 503 | (self.err_ty(), None) |
492 | } | 504 | } |
493 | }; | 505 | }; |
494 | 506 | ||
@@ -500,7 +512,7 @@ impl<'a> InferenceContext<'a> { | |||
500 | result | 512 | result |
501 | } else { | 513 | } else { |
502 | // FIXME diagnostic | 514 | // FIXME diagnostic |
503 | (Ty::Unknown, None) | 515 | (TyKind::Unknown.intern(&Interner), None) |
504 | } | 516 | } |
505 | } | 517 | } |
506 | 518 | ||
@@ -529,7 +541,7 @@ impl<'a> InferenceContext<'a> { | |||
529 | let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver) | 541 | let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver) |
530 | .with_impl_trait_mode(ImplTraitLoweringMode::Param); | 542 | .with_impl_trait_mode(ImplTraitLoweringMode::Param); |
531 | let param_tys = | 543 | let param_tys = |
532 | data.params.iter().map(|type_ref| Ty::from_hir(&ctx, type_ref)).collect::<Vec<_>>(); | 544 | data.params.iter().map(|type_ref| ctx.lower_ty(type_ref)).collect::<Vec<_>>(); |
533 | for (ty, pat) in param_tys.into_iter().zip(body.params.iter()) { | 545 | for (ty, pat) in param_tys.into_iter().zip(body.params.iter()) { |
534 | let ty = self.insert_type_vars(ty); | 546 | let ty = self.insert_type_vars(ty); |
535 | let ty = self.normalize_associated_types_in(ty); | 547 | let ty = self.normalize_associated_types_in(ty); |
@@ -711,12 +723,12 @@ impl Expectation { | |||
711 | 723 | ||
712 | /// This expresses no expectation on the type. | 724 | /// This expresses no expectation on the type. |
713 | fn none() -> Self { | 725 | fn none() -> Self { |
714 | Expectation { ty: Ty::Unknown, rvalue_hint: false } | 726 | Expectation { ty: TyKind::Unknown.intern(&Interner), rvalue_hint: false } |
715 | } | 727 | } |
716 | 728 | ||
717 | fn coercion_target(&self) -> &Ty { | 729 | fn coercion_target(&self) -> &Ty { |
718 | if self.rvalue_hint { | 730 | if self.rvalue_hint { |
719 | &Ty::Unknown | 731 | &Ty(TyKind::Unknown) |
720 | } else { | 732 | } else { |
721 | &self.ty | 733 | &self.ty |
722 | } | 734 | } |
diff --git a/crates/hir_ty/src/infer/coerce.rs b/crates/hir_ty/src/infer/coerce.rs index 7e8846f27..36670043a 100644 --- a/crates/hir_ty/src/infer/coerce.rs +++ b/crates/hir_ty/src/infer/coerce.rs | |||
@@ -7,7 +7,7 @@ | |||
7 | use chalk_ir::{Mutability, TyVariableKind}; | 7 | use chalk_ir::{Mutability, TyVariableKind}; |
8 | use hir_def::lang_item::LangItemTarget; | 8 | use hir_def::lang_item::LangItemTarget; |
9 | 9 | ||
10 | use crate::{autoderef, traits::Solution, Obligation, Substs, TraitRef, Ty}; | 10 | use crate::{autoderef, traits::Solution, Interner, Obligation, Substs, TraitRef, Ty, TyKind}; |
11 | 11 | ||
12 | use super::{InEnvironment, InferenceContext}; | 12 | use super::{InEnvironment, InferenceContext}; |
13 | 13 | ||
@@ -33,7 +33,9 @@ impl<'a> InferenceContext<'a> { | |||
33 | } else if self.coerce(ty2, ty1) { | 33 | } else if self.coerce(ty2, ty1) { |
34 | ty1.clone() | 34 | ty1.clone() |
35 | } else { | 35 | } else { |
36 | if let (Ty::FnDef(..), Ty::FnDef(..)) = (ty1, ty2) { | 36 | if let (TyKind::FnDef(..), TyKind::FnDef(..)) = |
37 | (ty1.interned(&Interner), ty2.interned(&Interner)) | ||
38 | { | ||
37 | cov_mark::hit!(coerce_fn_reification); | 39 | cov_mark::hit!(coerce_fn_reification); |
38 | // Special case: two function types. Try to coerce both to | 40 | // Special case: two function types. Try to coerce both to |
39 | // pointers to have a chance at getting a match. See | 41 | // pointers to have a chance at getting a match. See |
@@ -51,13 +53,13 @@ impl<'a> InferenceContext<'a> { | |||
51 | } | 53 | } |
52 | 54 | ||
53 | fn coerce_inner(&mut self, mut from_ty: Ty, to_ty: &Ty) -> bool { | 55 | fn coerce_inner(&mut self, mut from_ty: Ty, to_ty: &Ty) -> bool { |
54 | match (&from_ty, to_ty) { | 56 | match (from_ty.interned(&Interner), to_ty.interned(&Interner)) { |
55 | // Never type will make type variable to fallback to Never Type instead of Unknown. | 57 | // Never type will make type variable to fallback to Never Type instead of Unknown. |
56 | (Ty::Never, Ty::InferenceVar(tv, TyVariableKind::General)) => { | 58 | (TyKind::Never, TyKind::InferenceVar(tv, TyVariableKind::General)) => { |
57 | self.table.type_variable_table.set_diverging(*tv, true); | 59 | self.table.type_variable_table.set_diverging(*tv, true); |
58 | return true; | 60 | return true; |
59 | } | 61 | } |
60 | (Ty::Never, _) => return true, | 62 | (TyKind::Never, _) => return true, |
61 | 63 | ||
62 | // Trivial cases, this should go after `never` check to | 64 | // Trivial cases, this should go after `never` check to |
63 | // avoid infer result type to be never | 65 | // avoid infer result type to be never |
@@ -69,33 +71,33 @@ impl<'a> InferenceContext<'a> { | |||
69 | } | 71 | } |
70 | 72 | ||
71 | // Pointer weakening and function to pointer | 73 | // Pointer weakening and function to pointer |
72 | match (&mut from_ty, to_ty) { | 74 | match (&mut from_ty.0, to_ty.interned(&Interner)) { |
73 | // `*mut T` -> `*const T` | 75 | // `*mut T` -> `*const T` |
74 | // `&mut T` -> `&T` | 76 | // `&mut T` -> `&T` |
75 | (Ty::Raw(m1, ..), Ty::Raw(m2 @ Mutability::Not, ..)) | 77 | (TyKind::Raw(m1, ..), TyKind::Raw(m2 @ Mutability::Not, ..)) |
76 | | (Ty::Ref(m1, ..), Ty::Ref(m2 @ Mutability::Not, ..)) => { | 78 | | (TyKind::Ref(m1, ..), TyKind::Ref(m2 @ Mutability::Not, ..)) => { |
77 | *m1 = *m2; | 79 | *m1 = *m2; |
78 | } | 80 | } |
79 | // `&T` -> `*const T` | 81 | // `&T` -> `*const T` |
80 | // `&mut T` -> `*mut T`/`*const T` | 82 | // `&mut T` -> `*mut T`/`*const T` |
81 | (Ty::Ref(.., substs), &Ty::Raw(m2 @ Mutability::Not, ..)) | 83 | (TyKind::Ref(.., substs), &TyKind::Raw(m2 @ Mutability::Not, ..)) |
82 | | (Ty::Ref(Mutability::Mut, substs), &Ty::Raw(m2, ..)) => { | 84 | | (TyKind::Ref(Mutability::Mut, substs), &TyKind::Raw(m2, ..)) => { |
83 | from_ty = Ty::Raw(m2, substs.clone()); | 85 | from_ty = TyKind::Raw(m2, substs.clone()).intern(&Interner); |
84 | } | 86 | } |
85 | 87 | ||
86 | // Illegal mutability conversion | 88 | // Illegal mutability conversion |
87 | (Ty::Raw(Mutability::Not, ..), Ty::Raw(Mutability::Mut, ..)) | 89 | (TyKind::Raw(Mutability::Not, ..), TyKind::Raw(Mutability::Mut, ..)) |
88 | | (Ty::Ref(Mutability::Not, ..), Ty::Ref(Mutability::Mut, ..)) => return false, | 90 | | (TyKind::Ref(Mutability::Not, ..), TyKind::Ref(Mutability::Mut, ..)) => return false, |
89 | 91 | ||
90 | // `{function_type}` -> `fn()` | 92 | // `{function_type}` -> `fn()` |
91 | (Ty::FnDef(..), Ty::Function { .. }) => match from_ty.callable_sig(self.db) { | 93 | (TyKind::FnDef(..), TyKind::Function { .. }) => match from_ty.callable_sig(self.db) { |
92 | None => return false, | 94 | None => return false, |
93 | Some(sig) => { | 95 | Some(sig) => { |
94 | from_ty = Ty::fn_ptr(sig); | 96 | from_ty = Ty::fn_ptr(sig); |
95 | } | 97 | } |
96 | }, | 98 | }, |
97 | 99 | ||
98 | (Ty::Closure(.., substs), Ty::Function { .. }) => { | 100 | (TyKind::Closure(.., substs), TyKind::Function { .. }) => { |
99 | from_ty = substs[0].clone(); | 101 | from_ty = substs[0].clone(); |
100 | } | 102 | } |
101 | 103 | ||
@@ -107,9 +109,11 @@ impl<'a> InferenceContext<'a> { | |||
107 | } | 109 | } |
108 | 110 | ||
109 | // Auto Deref if cannot coerce | 111 | // Auto Deref if cannot coerce |
110 | match (&from_ty, to_ty) { | 112 | match (from_ty.interned(&Interner), to_ty.interned(&Interner)) { |
111 | // FIXME: DerefMut | 113 | // FIXME: DerefMut |
112 | (Ty::Ref(_, st1), Ty::Ref(_, st2)) => self.unify_autoderef_behind_ref(&st1[0], &st2[0]), | 114 | (TyKind::Ref(_, st1), TyKind::Ref(_, st2)) => { |
115 | self.unify_autoderef_behind_ref(&st1[0], &st2[0]) | ||
116 | } | ||
113 | 117 | ||
114 | // Otherwise, normal unify | 118 | // Otherwise, normal unify |
115 | _ => self.unify(&from_ty, to_ty), | 119 | _ => self.unify(&from_ty, to_ty), |
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs index 262177ffb..eee3e6ec5 100644 --- a/crates/hir_ty/src/infer/expr.rs +++ b/crates/hir_ty/src/infer/expr.rs | |||
@@ -18,10 +18,11 @@ use crate::{ | |||
18 | lower::lower_to_chalk_mutability, | 18 | lower::lower_to_chalk_mutability, |
19 | method_resolution, op, | 19 | method_resolution, op, |
20 | primitive::{self, UintTy}, | 20 | primitive::{self, UintTy}, |
21 | traits::{FnTrait, InEnvironment}, | 21 | to_assoc_type_id, |
22 | traits::{chalk::from_chalk, FnTrait, InEnvironment}, | ||
22 | utils::{generics, variant_data, Generics}, | 23 | utils::{generics, variant_data, Generics}, |
23 | AdtId, Binders, CallableDefId, FnPointer, FnSig, Obligation, OpaqueTyId, Rawness, Scalar, | 24 | AdtId, Binders, CallableDefId, FnPointer, FnSig, Interner, Obligation, Rawness, Scalar, Substs, |
24 | Substs, TraitRef, Ty, | 25 | TraitRef, Ty, TyKind, |
25 | }; | 26 | }; |
26 | 27 | ||
27 | use super::{ | 28 | use super::{ |
@@ -57,7 +58,7 @@ impl<'a> InferenceContext<'a> { | |||
57 | // Return actual type when type mismatch. | 58 | // Return actual type when type mismatch. |
58 | // This is needed for diagnostic when return type mismatch. | 59 | // This is needed for diagnostic when return type mismatch. |
59 | ty | 60 | ty |
60 | } else if expected.coercion_target() == &Ty::Unknown { | 61 | } else if expected.coercion_target().is_unknown() { |
61 | ty | 62 | ty |
62 | } else { | 63 | } else { |
63 | expected.ty.clone() | 64 | expected.ty.clone() |
@@ -84,7 +85,7 @@ impl<'a> InferenceContext<'a> { | |||
84 | arg_tys.push(arg); | 85 | arg_tys.push(arg); |
85 | } | 86 | } |
86 | let parameters = param_builder.build(); | 87 | let parameters = param_builder.build(); |
87 | let arg_ty = Ty::Tuple(num_args, parameters); | 88 | let arg_ty = TyKind::Tuple(num_args, parameters).intern(&Interner); |
88 | let substs = | 89 | let substs = |
89 | Substs::build_for_generics(&generic_params).push(ty.clone()).push(arg_ty).build(); | 90 | Substs::build_for_generics(&generic_params).push(ty.clone()).push(arg_ty).build(); |
90 | 91 | ||
@@ -97,8 +98,10 @@ impl<'a> InferenceContext<'a> { | |||
97 | }); | 98 | }); |
98 | if self.db.trait_solve(krate, goal.value).is_some() { | 99 | if self.db.trait_solve(krate, goal.value).is_some() { |
99 | self.obligations.push(implements_fn_trait); | 100 | self.obligations.push(implements_fn_trait); |
100 | let output_proj_ty = | 101 | let output_proj_ty = crate::ProjectionTy { |
101 | crate::ProjectionTy { associated_ty: output_assoc_type, parameters: substs }; | 102 | associated_ty: to_assoc_type_id(output_assoc_type), |
103 | parameters: substs, | ||
104 | }; | ||
102 | let return_ty = self.normalize_projection_ty(output_proj_ty); | 105 | let return_ty = self.normalize_projection_ty(output_proj_ty); |
103 | Some((arg_tys, return_ty)) | 106 | Some((arg_tys, return_ty)) |
104 | } else { | 107 | } else { |
@@ -116,10 +119,13 @@ impl<'a> InferenceContext<'a> { | |||
116 | fn infer_expr_inner(&mut self, tgt_expr: ExprId, expected: &Expectation) -> Ty { | 119 | fn infer_expr_inner(&mut self, tgt_expr: ExprId, expected: &Expectation) -> Ty { |
117 | let body = Arc::clone(&self.body); // avoid borrow checker problem | 120 | let body = Arc::clone(&self.body); // avoid borrow checker problem |
118 | let ty = match &body[tgt_expr] { | 121 | let ty = match &body[tgt_expr] { |
119 | Expr::Missing => Ty::Unknown, | 122 | Expr::Missing => self.err_ty(), |
120 | Expr::If { condition, then_branch, else_branch } => { | 123 | Expr::If { condition, then_branch, else_branch } => { |
121 | // if let is desugared to match, so this is always simple if | 124 | // if let is desugared to match, so this is always simple if |
122 | self.infer_expr(*condition, &Expectation::has_type(Ty::Scalar(Scalar::Bool))); | 125 | self.infer_expr( |
126 | *condition, | ||
127 | &Expectation::has_type(TyKind::Scalar(Scalar::Bool).intern(&Interner)), | ||
128 | ); | ||
123 | 129 | ||
124 | let condition_diverges = mem::replace(&mut self.diverges, Diverges::Maybe); | 130 | let condition_diverges = mem::replace(&mut self.diverges, Diverges::Maybe); |
125 | let mut both_arms_diverge = Diverges::Always; | 131 | let mut both_arms_diverge = Diverges::Always; |
@@ -167,14 +173,15 @@ impl<'a> InferenceContext<'a> { | |||
167 | Expr::TryBlock { body } => { | 173 | Expr::TryBlock { body } => { |
168 | let _inner = self.infer_expr(*body, expected); | 174 | let _inner = self.infer_expr(*body, expected); |
169 | // FIXME should be std::result::Result<{inner}, _> | 175 | // FIXME should be std::result::Result<{inner}, _> |
170 | Ty::Unknown | 176 | self.err_ty() |
171 | } | 177 | } |
172 | Expr::Async { body } => { | 178 | Expr::Async { body } => { |
173 | // Use the first type parameter as the output type of future. | 179 | // Use the first type parameter as the output type of future. |
174 | // existenail type AsyncBlockImplTrait<InnerType>: Future<Output = InnerType> | 180 | // existenail type AsyncBlockImplTrait<InnerType>: Future<Output = InnerType> |
175 | let inner_ty = self.infer_expr(*body, &Expectation::none()); | 181 | let inner_ty = self.infer_expr(*body, &Expectation::none()); |
176 | let opaque_ty_id = OpaqueTyId::AsyncBlockTypeImplTrait(self.owner, *body); | 182 | let impl_trait_id = crate::ImplTraitId::AsyncBlockTypeImplTrait(self.owner, *body); |
177 | Ty::OpaqueType(opaque_ty_id, Substs::single(inner_ty)) | 183 | let opaque_ty_id = self.db.intern_impl_trait_id(impl_trait_id).into(); |
184 | TyKind::OpaqueType(opaque_ty_id, Substs::single(inner_ty)).intern(&Interner) | ||
178 | } | 185 | } |
179 | Expr::Loop { body, label } => { | 186 | Expr::Loop { body, label } => { |
180 | self.breakables.push(BreakableContext { | 187 | self.breakables.push(BreakableContext { |
@@ -192,17 +199,20 @@ impl<'a> InferenceContext<'a> { | |||
192 | if ctxt.may_break { | 199 | if ctxt.may_break { |
193 | ctxt.break_ty | 200 | ctxt.break_ty |
194 | } else { | 201 | } else { |
195 | Ty::Never | 202 | TyKind::Never.intern(&Interner) |
196 | } | 203 | } |
197 | } | 204 | } |
198 | Expr::While { condition, body, label } => { | 205 | Expr::While { condition, body, label } => { |
199 | self.breakables.push(BreakableContext { | 206 | self.breakables.push(BreakableContext { |
200 | may_break: false, | 207 | may_break: false, |
201 | break_ty: Ty::Unknown, | 208 | break_ty: self.err_ty(), |
202 | label: label.map(|label| self.body[label].name.clone()), | 209 | label: label.map(|label| self.body[label].name.clone()), |
203 | }); | 210 | }); |
204 | // while let is desugared to a match loop, so this is always simple while | 211 | // while let is desugared to a match loop, so this is always simple while |
205 | self.infer_expr(*condition, &Expectation::has_type(Ty::Scalar(Scalar::Bool))); | 212 | self.infer_expr( |
213 | *condition, | ||
214 | &Expectation::has_type(TyKind::Scalar(Scalar::Bool).intern(&Interner)), | ||
215 | ); | ||
206 | self.infer_expr(*body, &Expectation::has_type(Ty::unit())); | 216 | self.infer_expr(*body, &Expectation::has_type(Ty::unit())); |
207 | let _ctxt = self.breakables.pop().expect("breakable stack broken"); | 217 | let _ctxt = self.breakables.pop().expect("breakable stack broken"); |
208 | // the body may not run, so it diverging doesn't mean we diverge | 218 | // the body may not run, so it diverging doesn't mean we diverge |
@@ -214,7 +224,7 @@ impl<'a> InferenceContext<'a> { | |||
214 | 224 | ||
215 | self.breakables.push(BreakableContext { | 225 | self.breakables.push(BreakableContext { |
216 | may_break: false, | 226 | may_break: false, |
217 | break_ty: Ty::Unknown, | 227 | break_ty: self.err_ty(), |
218 | label: label.map(|label| self.body[label].name.clone()), | 228 | label: label.map(|label| self.body[label].name.clone()), |
219 | }); | 229 | }); |
220 | let pat_ty = | 230 | let pat_ty = |
@@ -249,12 +259,15 @@ impl<'a> InferenceContext<'a> { | |||
249 | None => self.table.new_type_var(), | 259 | None => self.table.new_type_var(), |
250 | }; | 260 | }; |
251 | sig_tys.push(ret_ty.clone()); | 261 | sig_tys.push(ret_ty.clone()); |
252 | let sig_ty = Ty::Function(FnPointer { | 262 | let sig_ty = TyKind::Function(FnPointer { |
253 | num_args: sig_tys.len() - 1, | 263 | num_args: sig_tys.len() - 1, |
254 | sig: FnSig { variadic: false }, | 264 | sig: FnSig { variadic: false }, |
255 | substs: Substs(sig_tys.clone().into()), | 265 | substs: Substs(sig_tys.clone().into()), |
256 | }); | 266 | }) |
257 | let closure_ty = Ty::Closure(self.owner, tgt_expr, Substs::single(sig_ty)); | 267 | .intern(&Interner); |
268 | let closure_id = self.db.intern_closure((self.owner, tgt_expr)).into(); | ||
269 | let closure_ty = | ||
270 | TyKind::Closure(closure_id, Substs::single(sig_ty)).intern(&Interner); | ||
258 | 271 | ||
259 | // Eagerly try to relate the closure type with the expected | 272 | // Eagerly try to relate the closure type with the expected |
260 | // type, otherwise we often won't have enough information to | 273 | // type, otherwise we often won't have enough information to |
@@ -295,7 +308,7 @@ impl<'a> InferenceContext<'a> { | |||
295 | args.len(), | 308 | args.len(), |
296 | ) | 309 | ) |
297 | }) | 310 | }) |
298 | .unwrap_or((Vec::new(), Ty::Unknown)); | 311 | .unwrap_or((Vec::new(), self.err_ty())); |
299 | self.register_obligations_for_call(&callee_ty); | 312 | self.register_obligations_for_call(&callee_ty); |
300 | self.check_call_arguments(args, ¶m_tys); | 313 | self.check_call_arguments(args, ¶m_tys); |
301 | self.normalize_associated_types_in(ret_ty) | 314 | self.normalize_associated_types_in(ret_ty) |
@@ -305,8 +318,11 @@ impl<'a> InferenceContext<'a> { | |||
305 | Expr::Match { expr, arms } => { | 318 | Expr::Match { expr, arms } => { |
306 | let input_ty = self.infer_expr(*expr, &Expectation::none()); | 319 | let input_ty = self.infer_expr(*expr, &Expectation::none()); |
307 | 320 | ||
308 | let mut result_ty = | 321 | let mut result_ty = if arms.is_empty() { |
309 | if arms.is_empty() { Ty::Never } else { self.table.new_type_var() }; | 322 | TyKind::Never.intern(&Interner) |
323 | } else { | ||
324 | self.table.new_type_var() | ||
325 | }; | ||
310 | 326 | ||
311 | let matchee_diverges = self.diverges; | 327 | let matchee_diverges = self.diverges; |
312 | let mut all_arms_diverge = Diverges::Always; | 328 | let mut all_arms_diverge = Diverges::Always; |
@@ -317,7 +333,7 @@ impl<'a> InferenceContext<'a> { | |||
317 | if let Some(guard_expr) = arm.guard { | 333 | if let Some(guard_expr) = arm.guard { |
318 | self.infer_expr( | 334 | self.infer_expr( |
319 | guard_expr, | 335 | guard_expr, |
320 | &Expectation::has_type(Ty::Scalar(Scalar::Bool)), | 336 | &Expectation::has_type(TyKind::Scalar(Scalar::Bool).intern(&Interner)), |
321 | ); | 337 | ); |
322 | } | 338 | } |
323 | 339 | ||
@@ -333,9 +349,9 @@ impl<'a> InferenceContext<'a> { | |||
333 | Expr::Path(p) => { | 349 | Expr::Path(p) => { |
334 | // FIXME this could be more efficient... | 350 | // FIXME this could be more efficient... |
335 | let resolver = resolver_for_expr(self.db.upcast(), self.owner, tgt_expr); | 351 | let resolver = resolver_for_expr(self.db.upcast(), self.owner, tgt_expr); |
336 | self.infer_path(&resolver, p, tgt_expr.into()).unwrap_or(Ty::Unknown) | 352 | self.infer_path(&resolver, p, tgt_expr.into()).unwrap_or(self.err_ty()) |
337 | } | 353 | } |
338 | Expr::Continue { .. } => Ty::Never, | 354 | Expr::Continue { .. } => TyKind::Never.intern(&Interner), |
339 | Expr::Break { expr, label } => { | 355 | Expr::Break { expr, label } => { |
340 | let val_ty = if let Some(expr) = expr { | 356 | let val_ty = if let Some(expr) = expr { |
341 | self.infer_expr(*expr, &Expectation::none()) | 357 | self.infer_expr(*expr, &Expectation::none()) |
@@ -347,7 +363,7 @@ impl<'a> InferenceContext<'a> { | |||
347 | if let Some(ctxt) = find_breakable(&mut self.breakables, label.as_ref()) { | 363 | if let Some(ctxt) = find_breakable(&mut self.breakables, label.as_ref()) { |
348 | ctxt.break_ty.clone() | 364 | ctxt.break_ty.clone() |
349 | } else { | 365 | } else { |
350 | Ty::Unknown | 366 | self.err_ty() |
351 | }; | 367 | }; |
352 | 368 | ||
353 | let merged_type = self.coerce_merge_branch(&last_ty, &val_ty); | 369 | let merged_type = self.coerce_merge_branch(&last_ty, &val_ty); |
@@ -360,7 +376,7 @@ impl<'a> InferenceContext<'a> { | |||
360 | expr: tgt_expr, | 376 | expr: tgt_expr, |
361 | }); | 377 | }); |
362 | } | 378 | } |
363 | Ty::Never | 379 | TyKind::Never.intern(&Interner) |
364 | } | 380 | } |
365 | Expr::Return { expr } => { | 381 | Expr::Return { expr } => { |
366 | if let Some(expr) = expr { | 382 | if let Some(expr) = expr { |
@@ -369,14 +385,14 @@ impl<'a> InferenceContext<'a> { | |||
369 | let unit = Ty::unit(); | 385 | let unit = Ty::unit(); |
370 | self.coerce(&unit, &self.return_ty.clone()); | 386 | self.coerce(&unit, &self.return_ty.clone()); |
371 | } | 387 | } |
372 | Ty::Never | 388 | TyKind::Never.intern(&Interner) |
373 | } | 389 | } |
374 | Expr::Yield { expr } => { | 390 | Expr::Yield { expr } => { |
375 | // FIXME: track yield type for coercion | 391 | // FIXME: track yield type for coercion |
376 | if let Some(expr) = expr { | 392 | if let Some(expr) = expr { |
377 | self.infer_expr(*expr, &Expectation::none()); | 393 | self.infer_expr(*expr, &Expectation::none()); |
378 | } | 394 | } |
379 | Ty::Never | 395 | TyKind::Never.intern(&Interner) |
380 | } | 396 | } |
381 | Expr::RecordLit { path, fields, spread } => { | 397 | Expr::RecordLit { path, fields, spread } => { |
382 | let (ty, def_id) = self.resolve_variant(path.as_ref()); | 398 | let (ty, def_id) = self.resolve_variant(path.as_ref()); |
@@ -404,8 +420,9 @@ impl<'a> InferenceContext<'a> { | |||
404 | if let Some(field_def) = field_def { | 420 | if let Some(field_def) = field_def { |
405 | self.result.record_field_resolutions.insert(field.expr, field_def); | 421 | self.result.record_field_resolutions.insert(field.expr, field_def); |
406 | } | 422 | } |
407 | let field_ty = field_def | 423 | let field_ty = field_def.map_or(self.err_ty(), |it| { |
408 | .map_or(Ty::Unknown, |it| field_types[it.local_id].clone().subst(&substs)); | 424 | field_types[it.local_id].clone().subst(&substs) |
425 | }); | ||
409 | self.infer_expr_coerce(field.expr, &Expectation::has_type(field_ty)); | 426 | self.infer_expr_coerce(field.expr, &Expectation::has_type(field_ty)); |
410 | } | 427 | } |
411 | if let Some(expr) = spread { | 428 | if let Some(expr) = spread { |
@@ -424,27 +441,33 @@ impl<'a> InferenceContext<'a> { | |||
424 | environment: self.trait_env.clone(), | 441 | environment: self.trait_env.clone(), |
425 | }, | 442 | }, |
426 | ) | 443 | ) |
427 | .find_map(|derefed_ty| match canonicalized.decanonicalize_ty(derefed_ty.value) { | 444 | .find_map(|derefed_ty| { |
428 | Ty::Tuple(_, substs) => { | 445 | match canonicalized.decanonicalize_ty(derefed_ty.value).interned(&Interner) { |
429 | name.as_tuple_index().and_then(|idx| substs.0.get(idx).cloned()) | 446 | TyKind::Tuple(_, substs) => { |
430 | } | 447 | name.as_tuple_index().and_then(|idx| substs.0.get(idx).cloned()) |
431 | Ty::Adt(AdtId(hir_def::AdtId::StructId(s)), parameters) => { | 448 | } |
432 | self.db.struct_data(s).variant_data.field(name).map(|local_id| { | 449 | TyKind::Adt(AdtId(hir_def::AdtId::StructId(s)), parameters) => { |
433 | let field = FieldId { parent: s.into(), local_id }; | 450 | self.db.struct_data(*s).variant_data.field(name).map(|local_id| { |
434 | self.write_field_resolution(tgt_expr, field); | 451 | let field = FieldId { parent: (*s).into(), local_id }; |
435 | self.db.field_types(s.into())[field.local_id].clone().subst(¶meters) | 452 | self.write_field_resolution(tgt_expr, field); |
436 | }) | 453 | self.db.field_types((*s).into())[field.local_id] |
437 | } | 454 | .clone() |
438 | Ty::Adt(AdtId(hir_def::AdtId::UnionId(u)), parameters) => { | 455 | .subst(¶meters) |
439 | self.db.union_data(u).variant_data.field(name).map(|local_id| { | 456 | }) |
440 | let field = FieldId { parent: u.into(), local_id }; | 457 | } |
441 | self.write_field_resolution(tgt_expr, field); | 458 | TyKind::Adt(AdtId(hir_def::AdtId::UnionId(u)), parameters) => { |
442 | self.db.field_types(u.into())[field.local_id].clone().subst(¶meters) | 459 | self.db.union_data(*u).variant_data.field(name).map(|local_id| { |
443 | }) | 460 | let field = FieldId { parent: (*u).into(), local_id }; |
461 | self.write_field_resolution(tgt_expr, field); | ||
462 | self.db.field_types((*u).into())[field.local_id] | ||
463 | .clone() | ||
464 | .subst(¶meters) | ||
465 | }) | ||
466 | } | ||
467 | _ => None, | ||
444 | } | 468 | } |
445 | _ => None, | ||
446 | }) | 469 | }) |
447 | .unwrap_or(Ty::Unknown); | 470 | .unwrap_or(self.err_ty()); |
448 | let ty = self.insert_type_vars(ty); | 471 | let ty = self.insert_type_vars(ty); |
449 | self.normalize_associated_types_in(ty) | 472 | self.normalize_associated_types_in(ty) |
450 | } | 473 | } |
@@ -481,9 +504,10 @@ impl<'a> InferenceContext<'a> { | |||
481 | }; | 504 | }; |
482 | let inner_ty = self.infer_expr_inner(*expr, &expectation); | 505 | let inner_ty = self.infer_expr_inner(*expr, &expectation); |
483 | match rawness { | 506 | match rawness { |
484 | Rawness::RawPtr => Ty::Raw(mutability, Substs::single(inner_ty)), | 507 | Rawness::RawPtr => TyKind::Raw(mutability, Substs::single(inner_ty)), |
485 | Rawness::Ref => Ty::Ref(mutability, Substs::single(inner_ty)), | 508 | Rawness::Ref => TyKind::Ref(mutability, Substs::single(inner_ty)), |
486 | } | 509 | } |
510 | .intern(&Interner) | ||
487 | } | 511 | } |
488 | Expr::Box { expr } => { | 512 | Expr::Box { expr } => { |
489 | let inner_ty = self.infer_expr_inner(*expr, &Expectation::none()); | 513 | let inner_ty = self.infer_expr_inner(*expr, &Expectation::none()); |
@@ -499,7 +523,7 @@ impl<'a> InferenceContext<'a> { | |||
499 | sb = sb.fill(repeat_with(|| self.table.new_type_var())); | 523 | sb = sb.fill(repeat_with(|| self.table.new_type_var())); |
500 | Ty::adt_ty(box_, sb.build()) | 524 | Ty::adt_ty(box_, sb.build()) |
501 | } else { | 525 | } else { |
502 | Ty::Unknown | 526 | self.err_ty() |
503 | } | 527 | } |
504 | } | 528 | } |
505 | Expr::UnaryOp { expr, op } => { | 529 | Expr::UnaryOp { expr, op } => { |
@@ -519,31 +543,31 @@ impl<'a> InferenceContext<'a> { | |||
519 | Some(derefed_ty) => { | 543 | Some(derefed_ty) => { |
520 | canonicalized.decanonicalize_ty(derefed_ty.value) | 544 | canonicalized.decanonicalize_ty(derefed_ty.value) |
521 | } | 545 | } |
522 | None => Ty::Unknown, | 546 | None => self.err_ty(), |
523 | } | 547 | } |
524 | } | 548 | } |
525 | None => Ty::Unknown, | 549 | None => self.err_ty(), |
526 | }, | 550 | }, |
527 | UnaryOp::Neg => { | 551 | UnaryOp::Neg => { |
528 | match &inner_ty { | 552 | match inner_ty.interned(&Interner) { |
529 | // Fast path for builtins | 553 | // Fast path for builtins |
530 | Ty::Scalar(Scalar::Int(_)) | 554 | TyKind::Scalar(Scalar::Int(_)) |
531 | | Ty::Scalar(Scalar::Uint(_)) | 555 | | TyKind::Scalar(Scalar::Uint(_)) |
532 | | Ty::Scalar(Scalar::Float(_)) | 556 | | TyKind::Scalar(Scalar::Float(_)) |
533 | | Ty::InferenceVar(_, TyVariableKind::Integer) | 557 | | TyKind::InferenceVar(_, TyVariableKind::Integer) |
534 | | Ty::InferenceVar(_, TyVariableKind::Float) => inner_ty, | 558 | | TyKind::InferenceVar(_, TyVariableKind::Float) => inner_ty, |
535 | // Otherwise we resolve via the std::ops::Neg trait | 559 | // Otherwise we resolve via the std::ops::Neg trait |
536 | _ => self | 560 | _ => self |
537 | .resolve_associated_type(inner_ty, self.resolve_ops_neg_output()), | 561 | .resolve_associated_type(inner_ty, self.resolve_ops_neg_output()), |
538 | } | 562 | } |
539 | } | 563 | } |
540 | UnaryOp::Not => { | 564 | UnaryOp::Not => { |
541 | match &inner_ty { | 565 | match inner_ty.interned(&Interner) { |
542 | // Fast path for builtins | 566 | // Fast path for builtins |
543 | Ty::Scalar(Scalar::Bool) | 567 | TyKind::Scalar(Scalar::Bool) |
544 | | Ty::Scalar(Scalar::Int(_)) | 568 | | TyKind::Scalar(Scalar::Int(_)) |
545 | | Ty::Scalar(Scalar::Uint(_)) | 569 | | TyKind::Scalar(Scalar::Uint(_)) |
546 | | Ty::InferenceVar(_, TyVariableKind::Integer) => inner_ty, | 570 | | TyKind::InferenceVar(_, TyVariableKind::Integer) => inner_ty, |
547 | // Otherwise we resolve via the std::ops::Not trait | 571 | // Otherwise we resolve via the std::ops::Not trait |
548 | _ => self | 572 | _ => self |
549 | .resolve_associated_type(inner_ty, self.resolve_ops_not_output()), | 573 | .resolve_associated_type(inner_ty, self.resolve_ops_not_output()), |
@@ -554,7 +578,9 @@ impl<'a> InferenceContext<'a> { | |||
554 | Expr::BinaryOp { lhs, rhs, op } => match op { | 578 | Expr::BinaryOp { lhs, rhs, op } => match op { |
555 | Some(op) => { | 579 | Some(op) => { |
556 | let lhs_expectation = match op { | 580 | let lhs_expectation = match op { |
557 | BinaryOp::LogicOp(..) => Expectation::has_type(Ty::Scalar(Scalar::Bool)), | 581 | BinaryOp::LogicOp(..) => { |
582 | Expectation::has_type(TyKind::Scalar(Scalar::Bool).intern(&Interner)) | ||
583 | } | ||
558 | _ => Expectation::none(), | 584 | _ => Expectation::none(), |
559 | }; | 585 | }; |
560 | let lhs_ty = self.infer_expr(*lhs, &lhs_expectation); | 586 | let lhs_ty = self.infer_expr(*lhs, &lhs_expectation); |
@@ -563,7 +589,7 @@ impl<'a> InferenceContext<'a> { | |||
563 | 589 | ||
564 | let ret = op::binary_op_return_ty(*op, lhs_ty.clone(), rhs_ty.clone()); | 590 | let ret = op::binary_op_return_ty(*op, lhs_ty.clone(), rhs_ty.clone()); |
565 | 591 | ||
566 | if ret == Ty::Unknown { | 592 | if ret.is_unknown() { |
567 | cov_mark::hit!(infer_expr_inner_binary_operator_overload); | 593 | cov_mark::hit!(infer_expr_inner_binary_operator_overload); |
568 | 594 | ||
569 | self.resolve_associated_type_with_params( | 595 | self.resolve_associated_type_with_params( |
@@ -575,7 +601,7 @@ impl<'a> InferenceContext<'a> { | |||
575 | ret | 601 | ret |
576 | } | 602 | } |
577 | } | 603 | } |
578 | _ => Ty::Unknown, | 604 | _ => self.err_ty(), |
579 | }, | 605 | }, |
580 | Expr::Range { lhs, rhs, range_type } => { | 606 | Expr::Range { lhs, rhs, range_type } => { |
581 | let lhs_ty = lhs.map(|e| self.infer_expr_inner(e, &Expectation::none())); | 607 | let lhs_ty = lhs.map(|e| self.infer_expr_inner(e, &Expectation::none())); |
@@ -586,33 +612,33 @@ impl<'a> InferenceContext<'a> { | |||
586 | match (range_type, lhs_ty, rhs_ty) { | 612 | match (range_type, lhs_ty, rhs_ty) { |
587 | (RangeOp::Exclusive, None, None) => match self.resolve_range_full() { | 613 | (RangeOp::Exclusive, None, None) => match self.resolve_range_full() { |
588 | Some(adt) => Ty::adt_ty(adt, Substs::empty()), | 614 | Some(adt) => Ty::adt_ty(adt, Substs::empty()), |
589 | None => Ty::Unknown, | 615 | None => self.err_ty(), |
590 | }, | 616 | }, |
591 | (RangeOp::Exclusive, None, Some(ty)) => match self.resolve_range_to() { | 617 | (RangeOp::Exclusive, None, Some(ty)) => match self.resolve_range_to() { |
592 | Some(adt) => Ty::adt_ty(adt, Substs::single(ty)), | 618 | Some(adt) => Ty::adt_ty(adt, Substs::single(ty)), |
593 | None => Ty::Unknown, | 619 | None => self.err_ty(), |
594 | }, | 620 | }, |
595 | (RangeOp::Inclusive, None, Some(ty)) => { | 621 | (RangeOp::Inclusive, None, Some(ty)) => { |
596 | match self.resolve_range_to_inclusive() { | 622 | match self.resolve_range_to_inclusive() { |
597 | Some(adt) => Ty::adt_ty(adt, Substs::single(ty)), | 623 | Some(adt) => Ty::adt_ty(adt, Substs::single(ty)), |
598 | None => Ty::Unknown, | 624 | None => self.err_ty(), |
599 | } | 625 | } |
600 | } | 626 | } |
601 | (RangeOp::Exclusive, Some(_), Some(ty)) => match self.resolve_range() { | 627 | (RangeOp::Exclusive, Some(_), Some(ty)) => match self.resolve_range() { |
602 | Some(adt) => Ty::adt_ty(adt, Substs::single(ty)), | 628 | Some(adt) => Ty::adt_ty(adt, Substs::single(ty)), |
603 | None => Ty::Unknown, | 629 | None => self.err_ty(), |
604 | }, | 630 | }, |
605 | (RangeOp::Inclusive, Some(_), Some(ty)) => { | 631 | (RangeOp::Inclusive, Some(_), Some(ty)) => { |
606 | match self.resolve_range_inclusive() { | 632 | match self.resolve_range_inclusive() { |
607 | Some(adt) => Ty::adt_ty(adt, Substs::single(ty)), | 633 | Some(adt) => Ty::adt_ty(adt, Substs::single(ty)), |
608 | None => Ty::Unknown, | 634 | None => self.err_ty(), |
609 | } | 635 | } |
610 | } | 636 | } |
611 | (RangeOp::Exclusive, Some(ty), None) => match self.resolve_range_from() { | 637 | (RangeOp::Exclusive, Some(ty), None) => match self.resolve_range_from() { |
612 | Some(adt) => Ty::adt_ty(adt, Substs::single(ty)), | 638 | Some(adt) => Ty::adt_ty(adt, Substs::single(ty)), |
613 | None => Ty::Unknown, | 639 | None => self.err_ty(), |
614 | }, | 640 | }, |
615 | (RangeOp::Inclusive, _, None) => Ty::Unknown, | 641 | (RangeOp::Inclusive, _, None) => self.err_ty(), |
616 | } | 642 | } |
617 | } | 643 | } |
618 | Expr::Index { base, index } => { | 644 | Expr::Index { base, index } => { |
@@ -631,19 +657,19 @@ impl<'a> InferenceContext<'a> { | |||
631 | index_trait, | 657 | index_trait, |
632 | ); | 658 | ); |
633 | let self_ty = | 659 | let self_ty = |
634 | self_ty.map_or(Ty::Unknown, |t| canonicalized.decanonicalize_ty(t.value)); | 660 | self_ty.map_or(self.err_ty(), |t| canonicalized.decanonicalize_ty(t.value)); |
635 | self.resolve_associated_type_with_params( | 661 | self.resolve_associated_type_with_params( |
636 | self_ty, | 662 | self_ty, |
637 | self.resolve_ops_index_output(), | 663 | self.resolve_ops_index_output(), |
638 | &[index_ty], | 664 | &[index_ty], |
639 | ) | 665 | ) |
640 | } else { | 666 | } else { |
641 | Ty::Unknown | 667 | self.err_ty() |
642 | } | 668 | } |
643 | } | 669 | } |
644 | Expr::Tuple { exprs } => { | 670 | Expr::Tuple { exprs } => { |
645 | let mut tys = match &expected.ty { | 671 | let mut tys = match expected.ty.interned(&Interner) { |
646 | Ty::Tuple(_, substs) => substs | 672 | TyKind::Tuple(_, substs) => substs |
647 | .iter() | 673 | .iter() |
648 | .cloned() | 674 | .cloned() |
649 | .chain(repeat_with(|| self.table.new_type_var())) | 675 | .chain(repeat_with(|| self.table.new_type_var())) |
@@ -656,11 +682,11 @@ impl<'a> InferenceContext<'a> { | |||
656 | self.infer_expr_coerce(*expr, &Expectation::has_type(ty.clone())); | 682 | self.infer_expr_coerce(*expr, &Expectation::has_type(ty.clone())); |
657 | } | 683 | } |
658 | 684 | ||
659 | Ty::Tuple(tys.len(), Substs(tys.into())) | 685 | TyKind::Tuple(tys.len(), Substs(tys.into())).intern(&Interner) |
660 | } | 686 | } |
661 | Expr::Array(array) => { | 687 | Expr::Array(array) => { |
662 | let elem_ty = match &expected.ty { | 688 | let elem_ty = match expected.ty.interned(&Interner) { |
663 | Ty::Array(st) | Ty::Slice(st) => st.as_single().clone(), | 689 | TyKind::Array(st) | TyKind::Slice(st) => st.as_single().clone(), |
664 | _ => self.table.new_type_var(), | 690 | _ => self.table.new_type_var(), |
665 | }; | 691 | }; |
666 | 692 | ||
@@ -677,43 +703,51 @@ impl<'a> InferenceContext<'a> { | |||
677 | ); | 703 | ); |
678 | self.infer_expr( | 704 | self.infer_expr( |
679 | *repeat, | 705 | *repeat, |
680 | &Expectation::has_type(Ty::Scalar(Scalar::Uint(UintTy::Usize))), | 706 | &Expectation::has_type( |
707 | TyKind::Scalar(Scalar::Uint(UintTy::Usize)).intern(&Interner), | ||
708 | ), | ||
681 | ); | 709 | ); |
682 | } | 710 | } |
683 | } | 711 | } |
684 | 712 | ||
685 | Ty::Array(Substs::single(elem_ty)) | 713 | TyKind::Array(Substs::single(elem_ty)).intern(&Interner) |
686 | } | 714 | } |
687 | Expr::Literal(lit) => match lit { | 715 | Expr::Literal(lit) => match lit { |
688 | Literal::Bool(..) => Ty::Scalar(Scalar::Bool), | 716 | Literal::Bool(..) => TyKind::Scalar(Scalar::Bool).intern(&Interner), |
689 | Literal::String(..) => Ty::Ref(Mutability::Not, Substs::single(Ty::Str)), | 717 | Literal::String(..) => { |
718 | TyKind::Ref(Mutability::Not, Substs::single(TyKind::Str.intern(&Interner))) | ||
719 | .intern(&Interner) | ||
720 | } | ||
690 | Literal::ByteString(..) => { | 721 | Literal::ByteString(..) => { |
691 | let byte_type = Ty::Scalar(Scalar::Uint(UintTy::U8)); | 722 | let byte_type = TyKind::Scalar(Scalar::Uint(UintTy::U8)).intern(&Interner); |
692 | let array_type = Ty::Array(Substs::single(byte_type)); | 723 | let array_type = TyKind::Array(Substs::single(byte_type)).intern(&Interner); |
693 | Ty::Ref(Mutability::Not, Substs::single(array_type)) | 724 | TyKind::Ref(Mutability::Not, Substs::single(array_type)).intern(&Interner) |
694 | } | 725 | } |
695 | Literal::Char(..) => Ty::Scalar(Scalar::Char), | 726 | Literal::Char(..) => TyKind::Scalar(Scalar::Char).intern(&Interner), |
696 | Literal::Int(_v, ty) => match ty { | 727 | Literal::Int(_v, ty) => match ty { |
697 | Some(int_ty) => { | 728 | Some(int_ty) => { |
698 | Ty::Scalar(Scalar::Int(primitive::int_ty_from_builtin(*int_ty))) | 729 | TyKind::Scalar(Scalar::Int(primitive::int_ty_from_builtin(*int_ty))) |
730 | .intern(&Interner) | ||
699 | } | 731 | } |
700 | None => self.table.new_integer_var(), | 732 | None => self.table.new_integer_var(), |
701 | }, | 733 | }, |
702 | Literal::Uint(_v, ty) => match ty { | 734 | Literal::Uint(_v, ty) => match ty { |
703 | Some(int_ty) => { | 735 | Some(int_ty) => { |
704 | Ty::Scalar(Scalar::Uint(primitive::uint_ty_from_builtin(*int_ty))) | 736 | TyKind::Scalar(Scalar::Uint(primitive::uint_ty_from_builtin(*int_ty))) |
737 | .intern(&Interner) | ||
705 | } | 738 | } |
706 | None => self.table.new_integer_var(), | 739 | None => self.table.new_integer_var(), |
707 | }, | 740 | }, |
708 | Literal::Float(_v, ty) => match ty { | 741 | Literal::Float(_v, ty) => match ty { |
709 | Some(float_ty) => { | 742 | Some(float_ty) => { |
710 | Ty::Scalar(Scalar::Float(primitive::float_ty_from_builtin(*float_ty))) | 743 | TyKind::Scalar(Scalar::Float(primitive::float_ty_from_builtin(*float_ty))) |
744 | .intern(&Interner) | ||
711 | } | 745 | } |
712 | None => self.table.new_float_var(), | 746 | None => self.table.new_float_var(), |
713 | }, | 747 | }, |
714 | }, | 748 | }, |
715 | }; | 749 | }; |
716 | // use a new type variable if we got Ty::Unknown here | 750 | // use a new type variable if we got unknown here |
717 | let ty = self.insert_type_vars_shallow(ty); | 751 | let ty = self.insert_type_vars_shallow(ty); |
718 | let ty = self.resolve_ty_as_possible(ty); | 752 | let ty = self.resolve_ty_as_possible(ty); |
719 | self.write_expr_ty(tgt_expr, ty.clone()); | 753 | self.write_expr_ty(tgt_expr, ty.clone()); |
@@ -730,7 +764,7 @@ impl<'a> InferenceContext<'a> { | |||
730 | match stmt { | 764 | match stmt { |
731 | Statement::Let { pat, type_ref, initializer } => { | 765 | Statement::Let { pat, type_ref, initializer } => { |
732 | let decl_ty = | 766 | let decl_ty = |
733 | type_ref.as_ref().map(|tr| self.make_ty(tr)).unwrap_or(Ty::Unknown); | 767 | type_ref.as_ref().map(|tr| self.make_ty(tr)).unwrap_or(self.err_ty()); |
734 | 768 | ||
735 | // Always use the declared type when specified | 769 | // Always use the declared type when specified |
736 | let mut ty = decl_ty.clone(); | 770 | let mut ty = decl_ty.clone(); |
@@ -738,7 +772,7 @@ impl<'a> InferenceContext<'a> { | |||
738 | if let Some(expr) = initializer { | 772 | if let Some(expr) = initializer { |
739 | let actual_ty = | 773 | let actual_ty = |
740 | self.infer_expr_coerce(*expr, &Expectation::has_type(decl_ty.clone())); | 774 | self.infer_expr_coerce(*expr, &Expectation::has_type(decl_ty.clone())); |
741 | if decl_ty == Ty::Unknown { | 775 | if decl_ty.is_unknown() { |
742 | ty = actual_ty; | 776 | ty = actual_ty; |
743 | } | 777 | } |
744 | } | 778 | } |
@@ -802,7 +836,7 @@ impl<'a> InferenceContext<'a> { | |||
802 | self.write_method_resolution(tgt_expr, func); | 836 | self.write_method_resolution(tgt_expr, func); |
803 | (ty, self.db.value_ty(func.into()), Some(generics(self.db.upcast(), func.into()))) | 837 | (ty, self.db.value_ty(func.into()), Some(generics(self.db.upcast(), func.into()))) |
804 | } | 838 | } |
805 | None => (receiver_ty, Binders::new(0, Ty::Unknown), None), | 839 | None => (receiver_ty, Binders::new(0, self.err_ty()), None), |
806 | }; | 840 | }; |
807 | let substs = self.substs_for_method_call(def_generics, generic_args, &derefed_receiver_ty); | 841 | let substs = self.substs_for_method_call(def_generics, generic_args, &derefed_receiver_ty); |
808 | let method_ty = method_ty.subst(&substs); | 842 | let method_ty = method_ty.subst(&substs); |
@@ -813,15 +847,17 @@ impl<'a> InferenceContext<'a> { | |||
813 | if !sig.params().is_empty() { | 847 | if !sig.params().is_empty() { |
814 | (sig.params()[0].clone(), sig.params()[1..].to_vec(), sig.ret().clone()) | 848 | (sig.params()[0].clone(), sig.params()[1..].to_vec(), sig.ret().clone()) |
815 | } else { | 849 | } else { |
816 | (Ty::Unknown, Vec::new(), sig.ret().clone()) | 850 | (self.err_ty(), Vec::new(), sig.ret().clone()) |
817 | } | 851 | } |
818 | } | 852 | } |
819 | None => (Ty::Unknown, Vec::new(), Ty::Unknown), | 853 | None => (self.err_ty(), Vec::new(), self.err_ty()), |
820 | }; | 854 | }; |
821 | // Apply autoref so the below unification works correctly | 855 | // Apply autoref so the below unification works correctly |
822 | // FIXME: return correct autorefs from lookup_method | 856 | // FIXME: return correct autorefs from lookup_method |
823 | let actual_receiver_ty = match expected_receiver_ty.as_reference() { | 857 | let actual_receiver_ty = match expected_receiver_ty.as_reference() { |
824 | Some((_, mutability)) => Ty::Ref(mutability, Substs::single(derefed_receiver_ty)), | 858 | Some((_, mutability)) => { |
859 | TyKind::Ref(mutability, Substs::single(derefed_receiver_ty)).intern(&Interner) | ||
860 | } | ||
825 | _ => derefed_receiver_ty, | 861 | _ => derefed_receiver_ty, |
826 | }; | 862 | }; |
827 | self.unify(&expected_receiver_ty, &actual_receiver_ty); | 863 | self.unify(&expected_receiver_ty, &actual_receiver_ty); |
@@ -837,7 +873,7 @@ impl<'a> InferenceContext<'a> { | |||
837 | // that we have more information about the types of arguments when we | 873 | // that we have more information about the types of arguments when we |
838 | // type-check the functions. This isn't really the right way to do this. | 874 | // type-check the functions. This isn't really the right way to do this. |
839 | for &check_closures in &[false, true] { | 875 | for &check_closures in &[false, true] { |
840 | let param_iter = param_tys.iter().cloned().chain(repeat(Ty::Unknown)); | 876 | let param_iter = param_tys.iter().cloned().chain(repeat(self.err_ty())); |
841 | for (&arg, param_ty) in args.iter().zip(param_iter) { | 877 | for (&arg, param_ty) in args.iter().zip(param_iter) { |
842 | let is_closure = matches!(&self.body[arg], Expr::Lambda { .. }); | 878 | let is_closure = matches!(&self.body[arg], Expr::Lambda { .. }); |
843 | if is_closure != check_closures { | 879 | if is_closure != check_closures { |
@@ -867,7 +903,7 @@ impl<'a> InferenceContext<'a> { | |||
867 | if param.provenance == hir_def::generics::TypeParamProvenance::TraitSelf { | 903 | if param.provenance == hir_def::generics::TypeParamProvenance::TraitSelf { |
868 | substs.push(receiver_ty.clone()); | 904 | substs.push(receiver_ty.clone()); |
869 | } else { | 905 | } else { |
870 | substs.push(Ty::Unknown); | 906 | substs.push(self.err_ty()); |
871 | } | 907 | } |
872 | } | 908 | } |
873 | } | 909 | } |
@@ -891,14 +927,15 @@ impl<'a> InferenceContext<'a> { | |||
891 | }; | 927 | }; |
892 | let supplied_params = substs.len(); | 928 | let supplied_params = substs.len(); |
893 | for _ in supplied_params..total_len { | 929 | for _ in supplied_params..total_len { |
894 | substs.push(Ty::Unknown); | 930 | substs.push(self.err_ty()); |
895 | } | 931 | } |
896 | assert_eq!(substs.len(), total_len); | 932 | assert_eq!(substs.len(), total_len); |
897 | Substs(substs.into()) | 933 | Substs(substs.into()) |
898 | } | 934 | } |
899 | 935 | ||
900 | fn register_obligations_for_call(&mut self, callable_ty: &Ty) { | 936 | fn register_obligations_for_call(&mut self, callable_ty: &Ty) { |
901 | if let &Ty::FnDef(def, ref parameters) = callable_ty { | 937 | if let TyKind::FnDef(fn_def, parameters) = callable_ty.interned(&Interner) { |
938 | let def: CallableDefId = from_chalk(self.db, *fn_def); | ||
902 | let generic_predicates = self.db.generic_predicates(def.into()); | 939 | let generic_predicates = self.db.generic_predicates(def.into()); |
903 | for predicate in generic_predicates.iter() { | 940 | for predicate in generic_predicates.iter() { |
904 | let predicate = predicate.clone().subst(parameters); | 941 | let predicate = predicate.clone().subst(parameters); |
diff --git a/crates/hir_ty/src/infer/pat.rs b/crates/hir_ty/src/infer/pat.rs index a0ac8d80f..a16755cda 100644 --- a/crates/hir_ty/src/infer/pat.rs +++ b/crates/hir_ty/src/infer/pat.rs | |||
@@ -12,7 +12,7 @@ use hir_def::{ | |||
12 | use hir_expand::name::Name; | 12 | use hir_expand::name::Name; |
13 | 13 | ||
14 | use super::{BindingMode, Expectation, InferenceContext}; | 14 | use super::{BindingMode, Expectation, InferenceContext}; |
15 | use crate::{lower::lower_to_chalk_mutability, utils::variant_data, Substs, Ty}; | 15 | use crate::{lower::lower_to_chalk_mutability, utils::variant_data, Interner, Substs, Ty, TyKind}; |
16 | 16 | ||
17 | impl<'a> InferenceContext<'a> { | 17 | impl<'a> InferenceContext<'a> { |
18 | fn infer_tuple_struct_pat( | 18 | fn infer_tuple_struct_pat( |
@@ -46,7 +46,7 @@ impl<'a> InferenceContext<'a> { | |||
46 | let expected_ty = var_data | 46 | let expected_ty = var_data |
47 | .as_ref() | 47 | .as_ref() |
48 | .and_then(|d| d.field(&Name::new_tuple_field(i))) | 48 | .and_then(|d| d.field(&Name::new_tuple_field(i))) |
49 | .map_or(Ty::Unknown, |field| field_tys[field].clone().subst(&substs)); | 49 | .map_or(self.err_ty(), |field| field_tys[field].clone().subst(&substs)); |
50 | let expected_ty = self.normalize_associated_types_in(expected_ty); | 50 | let expected_ty = self.normalize_associated_types_in(expected_ty); |
51 | self.infer_pat(subpat, &expected_ty, default_bm); | 51 | self.infer_pat(subpat, &expected_ty, default_bm); |
52 | } | 52 | } |
@@ -80,8 +80,8 @@ impl<'a> InferenceContext<'a> { | |||
80 | self.result.record_pat_field_resolutions.insert(subpat.pat, field_def); | 80 | self.result.record_pat_field_resolutions.insert(subpat.pat, field_def); |
81 | } | 81 | } |
82 | 82 | ||
83 | let expected_ty = | 83 | let expected_ty = matching_field |
84 | matching_field.map_or(Ty::Unknown, |field| field_tys[field].clone().subst(&substs)); | 84 | .map_or(self.err_ty(), |field| field_tys[field].clone().subst(&substs)); |
85 | let expected_ty = self.normalize_associated_types_in(expected_ty); | 85 | let expected_ty = self.normalize_associated_types_in(expected_ty); |
86 | self.infer_pat(subpat.pat, &expected_ty, default_bm); | 86 | self.infer_pat(subpat.pat, &expected_ty, default_bm); |
87 | } | 87 | } |
@@ -129,7 +129,8 @@ impl<'a> InferenceContext<'a> { | |||
129 | None => (&args[..], &[][..]), | 129 | None => (&args[..], &[][..]), |
130 | }; | 130 | }; |
131 | let n_uncovered_patterns = expectations.len().saturating_sub(args.len()); | 131 | let n_uncovered_patterns = expectations.len().saturating_sub(args.len()); |
132 | let mut expectations_iter = expectations.iter().chain(repeat(&Ty::Unknown)); | 132 | let err_ty = self.err_ty(); |
133 | let mut expectations_iter = expectations.iter().chain(repeat(&err_ty)); | ||
133 | let mut infer_pat = |(&pat, ty)| self.infer_pat(pat, ty, default_bm); | 134 | let mut infer_pat = |(&pat, ty)| self.infer_pat(pat, ty, default_bm); |
134 | 135 | ||
135 | let mut inner_tys = Vec::with_capacity(n_uncovered_patterns + args.len()); | 136 | let mut inner_tys = Vec::with_capacity(n_uncovered_patterns + args.len()); |
@@ -137,7 +138,7 @@ impl<'a> InferenceContext<'a> { | |||
137 | inner_tys.extend(expectations_iter.by_ref().take(n_uncovered_patterns).cloned()); | 138 | inner_tys.extend(expectations_iter.by_ref().take(n_uncovered_patterns).cloned()); |
138 | inner_tys.extend(post.iter().zip(expectations_iter).map(infer_pat)); | 139 | inner_tys.extend(post.iter().zip(expectations_iter).map(infer_pat)); |
139 | 140 | ||
140 | Ty::Tuple(inner_tys.len(), Substs(inner_tys.into())) | 141 | TyKind::Tuple(inner_tys.len(), Substs(inner_tys.into())).intern(&Interner) |
141 | } | 142 | } |
142 | Pat::Or(ref pats) => { | 143 | Pat::Or(ref pats) => { |
143 | if let Some((first_pat, rest)) = pats.split_first() { | 144 | if let Some((first_pat, rest)) = pats.split_first() { |
@@ -147,7 +148,7 @@ impl<'a> InferenceContext<'a> { | |||
147 | } | 148 | } |
148 | ty | 149 | ty |
149 | } else { | 150 | } else { |
150 | Ty::Unknown | 151 | self.err_ty() |
151 | } | 152 | } |
152 | } | 153 | } |
153 | Pat::Ref { pat, mutability } => { | 154 | Pat::Ref { pat, mutability } => { |
@@ -159,10 +160,10 @@ impl<'a> InferenceContext<'a> { | |||
159 | } | 160 | } |
160 | inner_ty | 161 | inner_ty |
161 | } | 162 | } |
162 | _ => &Ty::Unknown, | 163 | _ => &Ty(TyKind::Unknown), |
163 | }; | 164 | }; |
164 | let subty = self.infer_pat(*pat, expectation, default_bm); | 165 | let subty = self.infer_pat(*pat, expectation, default_bm); |
165 | Ty::Ref(mutability, Substs::single(subty)) | 166 | TyKind::Ref(mutability, Substs::single(subty)).intern(&Interner) |
166 | } | 167 | } |
167 | Pat::TupleStruct { path: p, args: subpats, ellipsis } => self.infer_tuple_struct_pat( | 168 | Pat::TupleStruct { path: p, args: subpats, ellipsis } => self.infer_tuple_struct_pat( |
168 | p.as_ref(), | 169 | p.as_ref(), |
@@ -178,7 +179,7 @@ impl<'a> InferenceContext<'a> { | |||
178 | Pat::Path(path) => { | 179 | Pat::Path(path) => { |
179 | // FIXME use correct resolver for the surrounding expression | 180 | // FIXME use correct resolver for the surrounding expression |
180 | let resolver = self.resolver.clone(); | 181 | let resolver = self.resolver.clone(); |
181 | self.infer_path(&resolver, &path, pat.into()).unwrap_or(Ty::Unknown) | 182 | self.infer_path(&resolver, &path, pat.into()).unwrap_or(self.err_ty()) |
182 | } | 183 | } |
183 | Pat::Bind { mode, name: _, subpat } => { | 184 | Pat::Bind { mode, name: _, subpat } => { |
184 | let mode = if mode == &BindingAnnotation::Unannotated { | 185 | let mode = if mode == &BindingAnnotation::Unannotated { |
@@ -195,7 +196,7 @@ impl<'a> InferenceContext<'a> { | |||
195 | 196 | ||
196 | let bound_ty = match mode { | 197 | let bound_ty = match mode { |
197 | BindingMode::Ref(mutability) => { | 198 | BindingMode::Ref(mutability) => { |
198 | Ty::Ref(mutability, Substs::single(inner_ty.clone())) | 199 | TyKind::Ref(mutability, Substs::single(inner_ty.clone())).intern(&Interner) |
199 | } | 200 | } |
200 | BindingMode::Move => inner_ty.clone(), | 201 | BindingMode::Move => inner_ty.clone(), |
201 | }; | 202 | }; |
@@ -204,17 +205,17 @@ impl<'a> InferenceContext<'a> { | |||
204 | return inner_ty; | 205 | return inner_ty; |
205 | } | 206 | } |
206 | Pat::Slice { prefix, slice, suffix } => { | 207 | Pat::Slice { prefix, slice, suffix } => { |
207 | let (container_ty, elem_ty): (fn(_) -> _, _) = match &expected { | 208 | let (container_ty, elem_ty): (fn(_) -> _, _) = match expected.interned(&Interner) { |
208 | Ty::Array(st) => (Ty::Array, st.as_single().clone()), | 209 | TyKind::Array(st) => (TyKind::Array, st.as_single().clone()), |
209 | Ty::Slice(st) => (Ty::Slice, st.as_single().clone()), | 210 | TyKind::Slice(st) => (TyKind::Slice, st.as_single().clone()), |
210 | _ => (Ty::Slice, Ty::Unknown), | 211 | _ => (TyKind::Slice, self.err_ty()), |
211 | }; | 212 | }; |
212 | 213 | ||
213 | for pat_id in prefix.iter().chain(suffix) { | 214 | for pat_id in prefix.iter().chain(suffix) { |
214 | self.infer_pat(*pat_id, &elem_ty, default_bm); | 215 | self.infer_pat(*pat_id, &elem_ty, default_bm); |
215 | } | 216 | } |
216 | 217 | ||
217 | let pat_ty = container_ty(Substs::single(elem_ty)); | 218 | let pat_ty = container_ty(Substs::single(elem_ty)).intern(&Interner); |
218 | if let Some(slice_pat_id) = slice { | 219 | if let Some(slice_pat_id) = slice { |
219 | self.infer_pat(*slice_pat_id, &pat_ty, default_bm); | 220 | self.infer_pat(*slice_pat_id, &pat_ty, default_bm); |
220 | } | 221 | } |
@@ -232,20 +233,20 @@ impl<'a> InferenceContext<'a> { | |||
232 | Some(box_adt) => { | 233 | Some(box_adt) => { |
233 | let inner_expected = match expected.as_adt() { | 234 | let inner_expected = match expected.as_adt() { |
234 | Some((adt, substs)) if adt == box_adt => substs.as_single(), | 235 | Some((adt, substs)) if adt == box_adt => substs.as_single(), |
235 | _ => &Ty::Unknown, | 236 | _ => &Ty(TyKind::Unknown), |
236 | }; | 237 | }; |
237 | 238 | ||
238 | let inner_ty = self.infer_pat(*inner, inner_expected, default_bm); | 239 | let inner_ty = self.infer_pat(*inner, inner_expected, default_bm); |
239 | Ty::adt_ty(box_adt, Substs::single(inner_ty)) | 240 | Ty::adt_ty(box_adt, Substs::single(inner_ty)) |
240 | } | 241 | } |
241 | None => Ty::Unknown, | 242 | None => self.err_ty(), |
242 | }, | 243 | }, |
243 | Pat::ConstBlock(expr) => { | 244 | Pat::ConstBlock(expr) => { |
244 | self.infer_expr(*expr, &Expectation::has_type(expected.clone())) | 245 | self.infer_expr(*expr, &Expectation::has_type(expected.clone())) |
245 | } | 246 | } |
246 | Pat::Missing => Ty::Unknown, | 247 | Pat::Missing => self.err_ty(), |
247 | }; | 248 | }; |
248 | // use a new type variable if we got Ty::Unknown here | 249 | // use a new type variable if we got error type here |
249 | let ty = self.insert_type_vars_shallow(ty); | 250 | let ty = self.insert_type_vars_shallow(ty); |
250 | if !self.unify(&ty, expected) { | 251 | if !self.unify(&ty, expected) { |
251 | // FIXME record mismatch, we need to change the type of self.type_mismatches for that | 252 | // FIXME record mismatch, we need to change the type of self.type_mismatches for that |
diff --git a/crates/hir_ty/src/infer/path.rs b/crates/hir_ty/src/infer/path.rs index ae3554bac..af108fb6c 100644 --- a/crates/hir_ty/src/infer/path.rs +++ b/crates/hir_ty/src/infer/path.rs | |||
@@ -9,7 +9,7 @@ use hir_def::{ | |||
9 | }; | 9 | }; |
10 | use hir_expand::name::Name; | 10 | use hir_expand::name::Name; |
11 | 11 | ||
12 | use crate::{method_resolution, Substs, Ty, ValueTyDefId}; | 12 | use crate::{method_resolution, Interner, Substs, Ty, TyKind, ValueTyDefId}; |
13 | 13 | ||
14 | use super::{ExprOrPatId, InferenceContext, TraitRef}; | 14 | use super::{ExprOrPatId, InferenceContext, TraitRef}; |
15 | 15 | ||
@@ -40,7 +40,7 @@ impl<'a> InferenceContext<'a> { | |||
40 | let ty = self.make_ty(type_ref); | 40 | let ty = self.make_ty(type_ref); |
41 | let remaining_segments_for_ty = path.segments().take(path.segments().len() - 1); | 41 | let remaining_segments_for_ty = path.segments().take(path.segments().len() - 1); |
42 | let ctx = crate::lower::TyLoweringContext::new(self.db, &resolver); | 42 | let ctx = crate::lower::TyLoweringContext::new(self.db, &resolver); |
43 | let (ty, _) = Ty::from_type_relative_path(&ctx, ty, None, remaining_segments_for_ty); | 43 | let (ty, _) = ctx.lower_ty_relative_path(ty, None, remaining_segments_for_ty); |
44 | self.resolve_ty_assoc_item( | 44 | self.resolve_ty_assoc_item( |
45 | ty, | 45 | ty, |
46 | &path.segments().last().expect("path had at least one segment").name, | 46 | &path.segments().last().expect("path had at least one segment").name, |
@@ -79,7 +79,7 @@ impl<'a> InferenceContext<'a> { | |||
79 | } | 79 | } |
80 | ValueNs::ImplSelf(impl_id) => { | 80 | ValueNs::ImplSelf(impl_id) => { |
81 | let generics = crate::utils::generics(self.db.upcast(), impl_id.into()); | 81 | let generics = crate::utils::generics(self.db.upcast(), impl_id.into()); |
82 | let substs = Substs::type_params_for_generics(&generics); | 82 | let substs = Substs::type_params_for_generics(self.db, &generics); |
83 | let ty = self.db.impl_self_ty(impl_id).subst(&substs); | 83 | let ty = self.db.impl_self_ty(impl_id).subst(&substs); |
84 | if let Some((AdtId::StructId(struct_id), substs)) = ty.as_adt() { | 84 | if let Some((AdtId::StructId(struct_id), substs)) = ty.as_adt() { |
85 | let ty = self.db.value_ty(struct_id.into()).subst(&substs); | 85 | let ty = self.db.value_ty(struct_id.into()).subst(&substs); |
@@ -96,7 +96,7 @@ impl<'a> InferenceContext<'a> { | |||
96 | // self_subst is just for the parent | 96 | // self_subst is just for the parent |
97 | let parent_substs = self_subst.unwrap_or_else(Substs::empty); | 97 | let parent_substs = self_subst.unwrap_or_else(Substs::empty); |
98 | let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver); | 98 | let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver); |
99 | let substs = Ty::substs_from_path(&ctx, path, typable, true); | 99 | let substs = ctx.substs_from_path(path, typable, true); |
100 | let full_substs = Substs::builder(substs.len()) | 100 | let full_substs = Substs::builder(substs.len()) |
101 | .use_parent_substs(&parent_substs) | 101 | .use_parent_substs(&parent_substs) |
102 | .fill(substs.0[parent_substs.len()..].iter().cloned()) | 102 | .fill(substs.0[parent_substs.len()..].iter().cloned()) |
@@ -126,7 +126,8 @@ impl<'a> InferenceContext<'a> { | |||
126 | let segment = | 126 | let segment = |
127 | remaining_segments.last().expect("there should be at least one segment here"); | 127 | remaining_segments.last().expect("there should be at least one segment here"); |
128 | let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver); | 128 | let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver); |
129 | let trait_ref = TraitRef::from_resolved_path(&ctx, trait_, resolved_segment, None); | 129 | let trait_ref = |
130 | ctx.lower_trait_ref_from_resolved_path(trait_, resolved_segment, None); | ||
130 | self.resolve_trait_assoc_item(trait_ref, segment, id) | 131 | self.resolve_trait_assoc_item(trait_ref, segment, id) |
131 | } | 132 | } |
132 | (def, _) => { | 133 | (def, _) => { |
@@ -137,14 +138,13 @@ impl<'a> InferenceContext<'a> { | |||
137 | let remaining_segments_for_ty = | 138 | let remaining_segments_for_ty = |
138 | remaining_segments.take(remaining_segments.len() - 1); | 139 | remaining_segments.take(remaining_segments.len() - 1); |
139 | let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver); | 140 | let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver); |
140 | let (ty, _) = Ty::from_partly_resolved_hir_path( | 141 | let (ty, _) = ctx.lower_partly_resolved_path( |
141 | &ctx, | ||
142 | def, | 142 | def, |
143 | resolved_segment, | 143 | resolved_segment, |
144 | remaining_segments_for_ty, | 144 | remaining_segments_for_ty, |
145 | true, | 145 | true, |
146 | ); | 146 | ); |
147 | if let Ty::Unknown = ty { | 147 | if let TyKind::Unknown = ty.interned(&Interner) { |
148 | return None; | 148 | return None; |
149 | } | 149 | } |
150 | 150 | ||
@@ -209,7 +209,7 @@ impl<'a> InferenceContext<'a> { | |||
209 | name: &Name, | 209 | name: &Name, |
210 | id: ExprOrPatId, | 210 | id: ExprOrPatId, |
211 | ) -> Option<(ValueNs, Option<Substs>)> { | 211 | ) -> Option<(ValueNs, Option<Substs>)> { |
212 | if let Ty::Unknown = ty { | 212 | if let TyKind::Unknown = ty.interned(&Interner) { |
213 | return None; | 213 | return None; |
214 | } | 214 | } |
215 | 215 | ||
diff --git a/crates/hir_ty/src/infer/unify.rs b/crates/hir_ty/src/infer/unify.rs index 54fcfed10..16d89ed1b 100644 --- a/crates/hir_ty/src/infer/unify.rs +++ b/crates/hir_ty/src/infer/unify.rs | |||
@@ -7,8 +7,8 @@ use ena::unify::{InPlaceUnificationTable, NoError, UnifyKey, UnifyValue}; | |||
7 | 7 | ||
8 | use super::{InferenceContext, Obligation}; | 8 | use super::{InferenceContext, Obligation}; |
9 | use crate::{ | 9 | use crate::{ |
10 | BoundVar, Canonical, DebruijnIndex, GenericPredicate, InEnvironment, InferenceVar, Scalar, | 10 | BoundVar, Canonical, DebruijnIndex, GenericPredicate, InEnvironment, InferenceVar, Interner, |
11 | Substs, Ty, TypeWalk, | 11 | Scalar, Substs, Ty, TyKind, TypeWalk, |
12 | }; | 12 | }; |
13 | 13 | ||
14 | impl<'a> InferenceContext<'a> { | 14 | impl<'a> InferenceContext<'a> { |
@@ -49,8 +49,8 @@ impl<'a, 'b> Canonicalizer<'a, 'b> { | |||
49 | 49 | ||
50 | fn do_canonicalize<T: TypeWalk>(&mut self, t: T, binders: DebruijnIndex) -> T { | 50 | fn do_canonicalize<T: TypeWalk>(&mut self, t: T, binders: DebruijnIndex) -> T { |
51 | t.fold_binders( | 51 | t.fold_binders( |
52 | &mut |ty, binders| match ty { | 52 | &mut |ty, binders| match ty.interned(&Interner) { |
53 | Ty::InferenceVar(var, kind) => { | 53 | &TyKind::InferenceVar(var, kind) => { |
54 | let inner = var.to_inner(); | 54 | let inner = var.to_inner(); |
55 | if self.var_stack.contains(&inner) { | 55 | if self.var_stack.contains(&inner) { |
56 | // recursive type | 56 | // recursive type |
@@ -66,7 +66,7 @@ impl<'a, 'b> Canonicalizer<'a, 'b> { | |||
66 | } else { | 66 | } else { |
67 | let root = self.ctx.table.var_unification_table.find(inner); | 67 | let root = self.ctx.table.var_unification_table.find(inner); |
68 | let position = self.add(InferenceVar::from_inner(root), kind); | 68 | let position = self.add(InferenceVar::from_inner(root), kind); |
69 | Ty::BoundVar(BoundVar::new(binders, position)) | 69 | TyKind::BoundVar(BoundVar::new(binders, position)).intern(&Interner) |
70 | } | 70 | } |
71 | } | 71 | } |
72 | _ => ty, | 72 | _ => ty, |
@@ -108,10 +108,10 @@ impl<T> Canonicalized<T> { | |||
108 | pub(super) fn decanonicalize_ty(&self, mut ty: Ty) -> Ty { | 108 | pub(super) fn decanonicalize_ty(&self, mut ty: Ty) -> Ty { |
109 | ty.walk_mut_binders( | 109 | ty.walk_mut_binders( |
110 | &mut |ty, binders| { | 110 | &mut |ty, binders| { |
111 | if let &mut Ty::BoundVar(bound) = ty { | 111 | if let &mut TyKind::BoundVar(bound) = &mut ty.0 { |
112 | if bound.debruijn >= binders { | 112 | if bound.debruijn >= binders { |
113 | let (v, k) = self.free_vars[bound.index]; | 113 | let (v, k) = self.free_vars[bound.index]; |
114 | *ty = Ty::InferenceVar(v, k); | 114 | *ty = TyKind::InferenceVar(v, k).intern(&Interner); |
115 | } | 115 | } |
116 | } | 116 | } |
117 | }, | 117 | }, |
@@ -142,7 +142,7 @@ impl<T> Canonicalized<T> { | |||
142 | // eagerly replace projections in the type; we may be getting types | 142 | // eagerly replace projections in the type; we may be getting types |
143 | // e.g. from where clauses where this hasn't happened yet | 143 | // e.g. from where clauses where this hasn't happened yet |
144 | let ty = ctx.normalize_associated_types_in(ty.clone().subst_bound_vars(&new_vars)); | 144 | let ty = ctx.normalize_associated_types_in(ty.clone().subst_bound_vars(&new_vars)); |
145 | ctx.table.unify(&Ty::InferenceVar(v, k), &ty); | 145 | ctx.table.unify(&TyKind::InferenceVar(v, k).intern(&Interner), &ty); |
146 | } | 146 | } |
147 | } | 147 | } |
148 | } | 148 | } |
@@ -166,7 +166,10 @@ pub(crate) fn unify(tys: &Canonical<(Ty, Ty)>) -> Option<Substs> { | |||
166 | // (kind of hacky) | 166 | // (kind of hacky) |
167 | for (i, var) in vars.iter().enumerate() { | 167 | for (i, var) in vars.iter().enumerate() { |
168 | if &*table.resolve_ty_shallow(var) == var { | 168 | if &*table.resolve_ty_shallow(var) == var { |
169 | table.unify(var, &Ty::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, i))); | 169 | table.unify( |
170 | var, | ||
171 | &TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, i)).intern(&Interner), | ||
172 | ); | ||
170 | } | 173 | } |
171 | } | 174 | } |
172 | Some( | 175 | Some( |
@@ -196,11 +199,12 @@ impl TypeVariableTable { | |||
196 | 199 | ||
197 | fn fallback_value(&self, iv: InferenceVar, kind: TyVariableKind) -> Ty { | 200 | fn fallback_value(&self, iv: InferenceVar, kind: TyVariableKind) -> Ty { |
198 | match kind { | 201 | match kind { |
199 | _ if self.inner[iv.to_inner().0 as usize].diverging => Ty::Never, | 202 | _ if self.inner[iv.to_inner().0 as usize].diverging => TyKind::Never, |
200 | TyVariableKind::General => Ty::Unknown, | 203 | TyVariableKind::General => TyKind::Unknown, |
201 | TyVariableKind::Integer => Ty::Scalar(Scalar::Int(IntTy::I32)), | 204 | TyVariableKind::Integer => TyKind::Scalar(Scalar::Int(IntTy::I32)), |
202 | TyVariableKind::Float => Ty::Scalar(Scalar::Float(FloatTy::F64)), | 205 | TyVariableKind::Float => TyKind::Scalar(Scalar::Float(FloatTy::F64)), |
203 | } | 206 | } |
207 | .intern(&Interner) | ||
204 | } | 208 | } |
205 | } | 209 | } |
206 | 210 | ||
@@ -227,7 +231,7 @@ impl InferenceTable { | |||
227 | self.type_variable_table.push(TypeVariableData { diverging }); | 231 | self.type_variable_table.push(TypeVariableData { diverging }); |
228 | let key = self.var_unification_table.new_key(TypeVarValue::Unknown); | 232 | let key = self.var_unification_table.new_key(TypeVarValue::Unknown); |
229 | assert_eq!(key.0 as usize, self.type_variable_table.inner.len() - 1); | 233 | assert_eq!(key.0 as usize, self.type_variable_table.inner.len() - 1); |
230 | Ty::InferenceVar(InferenceVar::from_inner(key), kind) | 234 | TyKind::InferenceVar(InferenceVar::from_inner(key), kind).intern(&Interner) |
231 | } | 235 | } |
232 | 236 | ||
233 | pub(crate) fn new_type_var(&mut self) -> Ty { | 237 | pub(crate) fn new_type_var(&mut self) -> Ty { |
@@ -290,12 +294,12 @@ impl InferenceTable { | |||
290 | } | 294 | } |
291 | 295 | ||
292 | pub(super) fn unify_inner_trivial(&mut self, ty1: &Ty, ty2: &Ty, depth: usize) -> bool { | 296 | pub(super) fn unify_inner_trivial(&mut self, ty1: &Ty, ty2: &Ty, depth: usize) -> bool { |
293 | match (ty1, ty2) { | 297 | match (ty1.interned(&Interner), ty2.interned(&Interner)) { |
294 | (Ty::Unknown, _) | (_, Ty::Unknown) => true, | 298 | (TyKind::Unknown, _) | (_, TyKind::Unknown) => true, |
295 | 299 | ||
296 | (Ty::Placeholder(p1), Ty::Placeholder(p2)) if *p1 == *p2 => true, | 300 | (TyKind::Placeholder(p1), TyKind::Placeholder(p2)) if *p1 == *p2 => true, |
297 | 301 | ||
298 | (Ty::Dyn(dyn1), Ty::Dyn(dyn2)) if dyn1.len() == dyn2.len() => { | 302 | (TyKind::Dyn(dyn1), TyKind::Dyn(dyn2)) if dyn1.len() == dyn2.len() => { |
299 | for (pred1, pred2) in dyn1.iter().zip(dyn2.iter()) { | 303 | for (pred1, pred2) in dyn1.iter().zip(dyn2.iter()) { |
300 | if !self.unify_preds(pred1, pred2, depth + 1) { | 304 | if !self.unify_preds(pred1, pred2, depth + 1) { |
301 | return false; | 305 | return false; |
@@ -305,16 +309,16 @@ impl InferenceTable { | |||
305 | } | 309 | } |
306 | 310 | ||
307 | ( | 311 | ( |
308 | Ty::InferenceVar(tv1, TyVariableKind::General), | 312 | TyKind::InferenceVar(tv1, TyVariableKind::General), |
309 | Ty::InferenceVar(tv2, TyVariableKind::General), | 313 | TyKind::InferenceVar(tv2, TyVariableKind::General), |
310 | ) | 314 | ) |
311 | | ( | 315 | | ( |
312 | Ty::InferenceVar(tv1, TyVariableKind::Integer), | 316 | TyKind::InferenceVar(tv1, TyVariableKind::Integer), |
313 | Ty::InferenceVar(tv2, TyVariableKind::Integer), | 317 | TyKind::InferenceVar(tv2, TyVariableKind::Integer), |
314 | ) | 318 | ) |
315 | | ( | 319 | | ( |
316 | Ty::InferenceVar(tv1, TyVariableKind::Float), | 320 | TyKind::InferenceVar(tv1, TyVariableKind::Float), |
317 | Ty::InferenceVar(tv2, TyVariableKind::Float), | 321 | TyKind::InferenceVar(tv2, TyVariableKind::Float), |
318 | ) if self.type_variable_table.is_diverging(*tv1) | 322 | ) if self.type_variable_table.is_diverging(*tv1) |
319 | == self.type_variable_table.is_diverging(*tv2) => | 323 | == self.type_variable_table.is_diverging(*tv2) => |
320 | { | 324 | { |
@@ -326,24 +330,37 @@ impl InferenceTable { | |||
326 | // The order of MaybeNeverTypeVar matters here. | 330 | // The order of MaybeNeverTypeVar matters here. |
327 | // Unifying MaybeNeverTypeVar and TypeVar will let the latter become MaybeNeverTypeVar. | 331 | // Unifying MaybeNeverTypeVar and TypeVar will let the latter become MaybeNeverTypeVar. |
328 | // Unifying MaybeNeverTypeVar and other concrete type will let the former become it. | 332 | // Unifying MaybeNeverTypeVar and other concrete type will let the former become it. |
329 | (Ty::InferenceVar(tv, TyVariableKind::General), other) | 333 | (TyKind::InferenceVar(tv, TyVariableKind::General), other) |
330 | | (other, Ty::InferenceVar(tv, TyVariableKind::General)) | 334 | | (other, TyKind::InferenceVar(tv, TyVariableKind::General)) |
331 | | (Ty::InferenceVar(tv, TyVariableKind::Integer), other @ Ty::Scalar(Scalar::Int(_))) | ||
332 | | (other @ Ty::Scalar(Scalar::Int(_)), Ty::InferenceVar(tv, TyVariableKind::Integer)) | ||
333 | | ( | 335 | | ( |
334 | Ty::InferenceVar(tv, TyVariableKind::Integer), | 336 | TyKind::InferenceVar(tv, TyVariableKind::Integer), |
335 | other @ Ty::Scalar(Scalar::Uint(_)), | 337 | other @ TyKind::Scalar(Scalar::Int(_)), |
336 | ) | 338 | ) |
337 | | ( | 339 | | ( |
338 | other @ Ty::Scalar(Scalar::Uint(_)), | 340 | other @ TyKind::Scalar(Scalar::Int(_)), |
339 | Ty::InferenceVar(tv, TyVariableKind::Integer), | 341 | TyKind::InferenceVar(tv, TyVariableKind::Integer), |
340 | ) | 342 | ) |
341 | | (Ty::InferenceVar(tv, TyVariableKind::Float), other @ Ty::Scalar(Scalar::Float(_))) | 343 | | ( |
342 | | (other @ Ty::Scalar(Scalar::Float(_)), Ty::InferenceVar(tv, TyVariableKind::Float)) => | 344 | TyKind::InferenceVar(tv, TyVariableKind::Integer), |
343 | { | 345 | other @ TyKind::Scalar(Scalar::Uint(_)), |
346 | ) | ||
347 | | ( | ||
348 | other @ TyKind::Scalar(Scalar::Uint(_)), | ||
349 | TyKind::InferenceVar(tv, TyVariableKind::Integer), | ||
350 | ) | ||
351 | | ( | ||
352 | TyKind::InferenceVar(tv, TyVariableKind::Float), | ||
353 | other @ TyKind::Scalar(Scalar::Float(_)), | ||
354 | ) | ||
355 | | ( | ||
356 | other @ TyKind::Scalar(Scalar::Float(_)), | ||
357 | TyKind::InferenceVar(tv, TyVariableKind::Float), | ||
358 | ) => { | ||
344 | // the type var is unknown since we tried to resolve it | 359 | // the type var is unknown since we tried to resolve it |
345 | self.var_unification_table | 360 | self.var_unification_table.union_value( |
346 | .union_value(tv.to_inner(), TypeVarValue::Known(other.clone())); | 361 | tv.to_inner(), |
362 | TypeVarValue::Known(other.clone().intern(&Interner)), | ||
363 | ); | ||
347 | true | 364 | true |
348 | } | 365 | } |
349 | 366 | ||
@@ -387,8 +404,8 @@ impl InferenceTable { | |||
387 | if i > 0 { | 404 | if i > 0 { |
388 | cov_mark::hit!(type_var_resolves_to_int_var); | 405 | cov_mark::hit!(type_var_resolves_to_int_var); |
389 | } | 406 | } |
390 | match &*ty { | 407 | match &ty.0 { |
391 | Ty::InferenceVar(tv, _) => { | 408 | TyKind::InferenceVar(tv, _) => { |
392 | let inner = tv.to_inner(); | 409 | let inner = tv.to_inner(); |
393 | match self.var_unification_table.inlined_probe_value(inner).known() { | 410 | match self.var_unification_table.inlined_probe_value(inner).known() { |
394 | Some(known_ty) => { | 411 | Some(known_ty) => { |
@@ -410,8 +427,8 @@ impl InferenceTable { | |||
410 | /// be resolved as far as possible, i.e. contain no type variables with | 427 | /// be resolved as far as possible, i.e. contain no type variables with |
411 | /// known type. | 428 | /// known type. |
412 | fn resolve_ty_as_possible_inner(&mut self, tv_stack: &mut Vec<TypeVarId>, ty: Ty) -> Ty { | 429 | fn resolve_ty_as_possible_inner(&mut self, tv_stack: &mut Vec<TypeVarId>, ty: Ty) -> Ty { |
413 | ty.fold(&mut |ty| match ty { | 430 | ty.fold(&mut |ty| match ty.interned(&Interner) { |
414 | Ty::InferenceVar(tv, kind) => { | 431 | &TyKind::InferenceVar(tv, kind) => { |
415 | let inner = tv.to_inner(); | 432 | let inner = tv.to_inner(); |
416 | if tv_stack.contains(&inner) { | 433 | if tv_stack.contains(&inner) { |
417 | cov_mark::hit!(type_var_cycles_resolve_as_possible); | 434 | cov_mark::hit!(type_var_cycles_resolve_as_possible); |
@@ -435,10 +452,10 @@ impl InferenceTable { | |||
435 | } | 452 | } |
436 | 453 | ||
437 | /// Resolves the type completely; type variables without known type are | 454 | /// Resolves the type completely; type variables without known type are |
438 | /// replaced by Ty::Unknown. | 455 | /// replaced by TyKind::Unknown. |
439 | fn resolve_ty_completely_inner(&mut self, tv_stack: &mut Vec<TypeVarId>, ty: Ty) -> Ty { | 456 | fn resolve_ty_completely_inner(&mut self, tv_stack: &mut Vec<TypeVarId>, ty: Ty) -> Ty { |
440 | ty.fold(&mut |ty| match ty { | 457 | ty.fold(&mut |ty| match ty.interned(&Interner) { |
441 | Ty::InferenceVar(tv, kind) => { | 458 | &TyKind::InferenceVar(tv, kind) => { |
442 | let inner = tv.to_inner(); | 459 | let inner = tv.to_inner(); |
443 | if tv_stack.contains(&inner) { | 460 | if tv_stack.contains(&inner) { |
444 | cov_mark::hit!(type_var_cycles_resolve_completely); | 461 | cov_mark::hit!(type_var_cycles_resolve_completely); |
diff --git a/crates/hir_ty/src/lib.rs b/crates/hir_ty/src/lib.rs index e77f24e4e..d6ff968f0 100644 --- a/crates/hir_ty/src/lib.rs +++ b/crates/hir_ty/src/lib.rs | |||
@@ -27,9 +27,8 @@ use std::{iter, mem, ops::Deref, sync::Arc}; | |||
27 | 27 | ||
28 | use base_db::salsa; | 28 | use base_db::salsa; |
29 | use hir_def::{ | 29 | use hir_def::{ |
30 | builtin_type::BuiltinType, expr::ExprId, type_ref::Rawness, AssocContainerId, DefWithBodyId, | 30 | builtin_type::BuiltinType, expr::ExprId, type_ref::Rawness, AssocContainerId, FunctionId, |
31 | FunctionId, GenericDefId, HasModule, LifetimeParamId, Lookup, TraitId, TypeAliasId, | 31 | GenericDefId, HasModule, LifetimeParamId, Lookup, TraitId, TypeAliasId, TypeParamId, |
32 | TypeParamId, | ||
33 | }; | 32 | }; |
34 | use itertools::Itertools; | 33 | use itertools::Itertools; |
35 | 34 | ||
@@ -49,7 +48,14 @@ pub use traits::{InEnvironment, Obligation, ProjectionPredicate, TraitEnvironmen | |||
49 | 48 | ||
50 | pub use chalk_ir::{AdtId, BoundVar, DebruijnIndex, Mutability, Scalar, TyVariableKind}; | 49 | pub use chalk_ir::{AdtId, BoundVar, DebruijnIndex, Mutability, Scalar, TyVariableKind}; |
51 | 50 | ||
52 | pub(crate) use crate::traits::chalk::Interner; | 51 | pub use crate::traits::chalk::Interner; |
52 | |||
53 | pub type ForeignDefId = chalk_ir::ForeignDefId<Interner>; | ||
54 | pub type AssocTypeId = chalk_ir::AssocTypeId<Interner>; | ||
55 | pub type FnDefId = chalk_ir::FnDefId<Interner>; | ||
56 | pub type ClosureId = chalk_ir::ClosureId<Interner>; | ||
57 | pub type OpaqueTyId = chalk_ir::OpaqueTyId<Interner>; | ||
58 | pub type PlaceholderIndex = chalk_ir::PlaceholderIndex; | ||
53 | 59 | ||
54 | #[derive(Clone, PartialEq, Eq, Debug, Hash)] | 60 | #[derive(Clone, PartialEq, Eq, Debug, Hash)] |
55 | pub enum Lifetime { | 61 | pub enum Lifetime { |
@@ -68,7 +74,7 @@ pub struct OpaqueTy { | |||
68 | /// trait and all its parameters are fully known. | 74 | /// trait and all its parameters are fully known. |
69 | #[derive(Clone, PartialEq, Eq, Debug, Hash)] | 75 | #[derive(Clone, PartialEq, Eq, Debug, Hash)] |
70 | pub struct ProjectionTy { | 76 | pub struct ProjectionTy { |
71 | pub associated_ty: TypeAliasId, | 77 | pub associated_ty: AssocTypeId, |
72 | pub parameters: Substs, | 78 | pub parameters: Substs, |
73 | } | 79 | } |
74 | 80 | ||
@@ -78,7 +84,7 @@ impl ProjectionTy { | |||
78 | } | 84 | } |
79 | 85 | ||
80 | fn trait_(&self, db: &dyn HirDatabase) -> TraitId { | 86 | fn trait_(&self, db: &dyn HirDatabase) -> TraitId { |
81 | match self.associated_ty.lookup(db.upcast()).container { | 87 | match from_assoc_type_id(self.associated_ty).lookup(db.upcast()).container { |
82 | AssocContainerId::TraitId(it) => it, | 88 | AssocContainerId::TraitId(it) => it, |
83 | _ => panic!("projection ty without parent trait"), | 89 | _ => panic!("projection ty without parent trait"), |
84 | } | 90 | } |
@@ -131,7 +137,7 @@ pub enum AliasTy { | |||
131 | /// | 137 | /// |
132 | /// This should be cheap to clone. | 138 | /// This should be cheap to clone. |
133 | #[derive(Clone, PartialEq, Eq, Debug, Hash)] | 139 | #[derive(Clone, PartialEq, Eq, Debug, Hash)] |
134 | pub enum Ty { | 140 | pub enum TyKind { |
135 | /// Structures, enumerations and unions. | 141 | /// Structures, enumerations and unions. |
136 | Adt(AdtId<Interner>, Substs), | 142 | Adt(AdtId<Interner>, Substs), |
137 | 143 | ||
@@ -139,7 +145,7 @@ pub enum Ty { | |||
139 | /// when we have tried to normalize a projection like `T::Item` but | 145 | /// when we have tried to normalize a projection like `T::Item` but |
140 | /// couldn't find a better representation. In that case, we generate | 146 | /// couldn't find a better representation. In that case, we generate |
141 | /// an **application type** like `(Iterator::Item)<T>`. | 147 | /// an **application type** like `(Iterator::Item)<T>`. |
142 | AssociatedType(TypeAliasId, Substs), | 148 | AssociatedType(AssocTypeId, Substs), |
143 | 149 | ||
144 | /// a scalar type like `bool` or `u32` | 150 | /// a scalar type like `bool` or `u32` |
145 | Scalar(Scalar), | 151 | Scalar(Scalar), |
@@ -179,7 +185,7 @@ pub enum Ty { | |||
179 | /// fn foo() -> i32 { 1 } | 185 | /// fn foo() -> i32 { 1 } |
180 | /// let bar = foo; // bar: fn() -> i32 {foo} | 186 | /// let bar = foo; // bar: fn() -> i32 {foo} |
181 | /// ``` | 187 | /// ``` |
182 | FnDef(CallableDefId, Substs), | 188 | FnDef(FnDefId, Substs), |
183 | 189 | ||
184 | /// The pointee of a string slice. Written as `str`. | 190 | /// The pointee of a string slice. Written as `str`. |
185 | Str, | 191 | Str, |
@@ -191,10 +197,10 @@ pub enum Ty { | |||
191 | /// | 197 | /// |
192 | /// The closure signature is stored in a `FnPtr` type in the first type | 198 | /// The closure signature is stored in a `FnPtr` type in the first type |
193 | /// parameter. | 199 | /// parameter. |
194 | Closure(DefWithBodyId, ExprId, Substs), | 200 | Closure(ClosureId, Substs), |
195 | 201 | ||
196 | /// Represents a foreign type declared in external blocks. | 202 | /// Represents a foreign type declared in external blocks. |
197 | ForeignType(TypeAliasId), | 203 | ForeignType(ForeignDefId), |
198 | 204 | ||
199 | /// A pointer to a function. Written as `fn() -> i32`. | 205 | /// A pointer to a function. Written as `fn() -> i32`. |
200 | /// | 206 | /// |
@@ -216,7 +222,7 @@ pub enum Ty { | |||
216 | /// {}` when we're type-checking the body of that function. In this | 222 | /// {}` when we're type-checking the body of that function. In this |
217 | /// situation, we know this stands for *some* type, but don't know the exact | 223 | /// situation, we know this stands for *some* type, but don't know the exact |
218 | /// type. | 224 | /// type. |
219 | Placeholder(TypeParamId), | 225 | Placeholder(PlaceholderIndex), |
220 | 226 | ||
221 | /// A bound type variable. This is used in various places: when representing | 227 | /// A bound type variable. This is used in various places: when representing |
222 | /// some polymorphic type like the type of function `fn f<T>`, the type | 228 | /// some polymorphic type like the type of function `fn f<T>`, the type |
@@ -244,6 +250,21 @@ pub enum Ty { | |||
244 | Unknown, | 250 | Unknown, |
245 | } | 251 | } |
246 | 252 | ||
253 | #[derive(Clone, PartialEq, Eq, Debug, Hash)] | ||
254 | pub struct Ty(TyKind); | ||
255 | |||
256 | impl TyKind { | ||
257 | pub fn intern(self, _interner: &Interner) -> Ty { | ||
258 | Ty(self) | ||
259 | } | ||
260 | } | ||
261 | |||
262 | impl Ty { | ||
263 | pub fn interned(&self, _interner: &Interner) -> &TyKind { | ||
264 | &self.0 | ||
265 | } | ||
266 | } | ||
267 | |||
247 | /// A list of substitutions for generic parameters. | 268 | /// A list of substitutions for generic parameters. |
248 | #[derive(Clone, PartialEq, Eq, Debug, Hash)] | 269 | #[derive(Clone, PartialEq, Eq, Debug, Hash)] |
249 | pub struct Substs(Arc<[Ty]>); | 270 | pub struct Substs(Arc<[Ty]>); |
@@ -291,14 +312,22 @@ impl Substs { | |||
291 | } | 312 | } |
292 | 313 | ||
293 | /// Return Substs that replace each parameter by itself (i.e. `Ty::Param`). | 314 | /// Return Substs that replace each parameter by itself (i.e. `Ty::Param`). |
294 | pub(crate) fn type_params_for_generics(generic_params: &Generics) -> Substs { | 315 | pub(crate) fn type_params_for_generics( |
295 | Substs(generic_params.iter().map(|(id, _)| Ty::Placeholder(id)).collect()) | 316 | db: &dyn HirDatabase, |
317 | generic_params: &Generics, | ||
318 | ) -> Substs { | ||
319 | Substs( | ||
320 | generic_params | ||
321 | .iter() | ||
322 | .map(|(id, _)| TyKind::Placeholder(to_placeholder_idx(db, id)).intern(&Interner)) | ||
323 | .collect(), | ||
324 | ) | ||
296 | } | 325 | } |
297 | 326 | ||
298 | /// Return Substs that replace each parameter by itself (i.e. `Ty::Param`). | 327 | /// Return Substs that replace each parameter by itself (i.e. `Ty::Param`). |
299 | pub fn type_params(db: &dyn HirDatabase, def: impl Into<GenericDefId>) -> Substs { | 328 | pub fn type_params(db: &dyn HirDatabase, def: impl Into<GenericDefId>) -> Substs { |
300 | let params = generics(db.upcast(), def.into()); | 329 | let params = generics(db.upcast(), def.into()); |
301 | Substs::type_params_for_generics(¶ms) | 330 | Substs::type_params_for_generics(db, ¶ms) |
302 | } | 331 | } |
303 | 332 | ||
304 | /// Return Substs that replace each parameter by a bound variable. | 333 | /// Return Substs that replace each parameter by a bound variable. |
@@ -307,7 +336,7 @@ impl Substs { | |||
307 | generic_params | 336 | generic_params |
308 | .iter() | 337 | .iter() |
309 | .enumerate() | 338 | .enumerate() |
310 | .map(|(idx, _)| Ty::BoundVar(BoundVar::new(debruijn, idx))) | 339 | .map(|(idx, _)| TyKind::BoundVar(BoundVar::new(debruijn, idx)).intern(&Interner)) |
311 | .collect(), | 340 | .collect(), |
312 | ) | 341 | ) |
313 | } | 342 | } |
@@ -355,11 +384,14 @@ impl SubstsBuilder { | |||
355 | } | 384 | } |
356 | 385 | ||
357 | pub fn fill_with_bound_vars(self, debruijn: DebruijnIndex, starting_from: usize) -> Self { | 386 | pub fn fill_with_bound_vars(self, debruijn: DebruijnIndex, starting_from: usize) -> Self { |
358 | self.fill((starting_from..).map(|idx| Ty::BoundVar(BoundVar::new(debruijn, idx)))) | 387 | self.fill( |
388 | (starting_from..) | ||
389 | .map(|idx| TyKind::BoundVar(BoundVar::new(debruijn, idx)).intern(&Interner)), | ||
390 | ) | ||
359 | } | 391 | } |
360 | 392 | ||
361 | pub fn fill_with_unknown(self) -> Self { | 393 | pub fn fill_with_unknown(self) -> Self { |
362 | self.fill(iter::repeat(Ty::Unknown)) | 394 | self.fill(iter::repeat(TyKind::Unknown.intern(&Interner))) |
363 | } | 395 | } |
364 | 396 | ||
365 | pub fn fill(mut self, filler: impl Iterator<Item = Ty>) -> Self { | 397 | pub fn fill(mut self, filler: impl Iterator<Item = Ty>) -> Self { |
@@ -601,45 +633,52 @@ impl TypeWalk for CallableSig { | |||
601 | 633 | ||
602 | impl Ty { | 634 | impl Ty { |
603 | pub fn unit() -> Self { | 635 | pub fn unit() -> Self { |
604 | Ty::Tuple(0, Substs::empty()) | 636 | TyKind::Tuple(0, Substs::empty()).intern(&Interner) |
605 | } | 637 | } |
606 | 638 | ||
607 | pub fn adt_ty(adt: hir_def::AdtId, substs: Substs) -> Ty { | 639 | pub fn adt_ty(adt: hir_def::AdtId, substs: Substs) -> Ty { |
608 | Ty::Adt(AdtId(adt), substs) | 640 | TyKind::Adt(AdtId(adt), substs).intern(&Interner) |
609 | } | 641 | } |
610 | 642 | ||
611 | pub fn fn_ptr(sig: CallableSig) -> Self { | 643 | pub fn fn_ptr(sig: CallableSig) -> Self { |
612 | Ty::Function(FnPointer { | 644 | TyKind::Function(FnPointer { |
613 | num_args: sig.params().len(), | 645 | num_args: sig.params().len(), |
614 | sig: FnSig { variadic: sig.is_varargs }, | 646 | sig: FnSig { variadic: sig.is_varargs }, |
615 | substs: Substs(sig.params_and_return), | 647 | substs: Substs(sig.params_and_return), |
616 | }) | 648 | }) |
649 | .intern(&Interner) | ||
617 | } | 650 | } |
618 | 651 | ||
619 | pub fn builtin(builtin: BuiltinType) -> Self { | 652 | pub fn builtin(builtin: BuiltinType) -> Self { |
620 | match builtin { | 653 | match builtin { |
621 | BuiltinType::Char => Ty::Scalar(Scalar::Char), | 654 | BuiltinType::Char => TyKind::Scalar(Scalar::Char).intern(&Interner), |
622 | BuiltinType::Bool => Ty::Scalar(Scalar::Bool), | 655 | BuiltinType::Bool => TyKind::Scalar(Scalar::Bool).intern(&Interner), |
623 | BuiltinType::Str => Ty::Str, | 656 | BuiltinType::Str => TyKind::Str.intern(&Interner), |
624 | BuiltinType::Int(t) => Ty::Scalar(Scalar::Int(primitive::int_ty_from_builtin(t))), | 657 | BuiltinType::Int(t) => { |
625 | BuiltinType::Uint(t) => Ty::Scalar(Scalar::Uint(primitive::uint_ty_from_builtin(t))), | 658 | TyKind::Scalar(Scalar::Int(primitive::int_ty_from_builtin(t))).intern(&Interner) |
626 | BuiltinType::Float(t) => Ty::Scalar(Scalar::Float(primitive::float_ty_from_builtin(t))), | 659 | } |
660 | BuiltinType::Uint(t) => { | ||
661 | TyKind::Scalar(Scalar::Uint(primitive::uint_ty_from_builtin(t))).intern(&Interner) | ||
662 | } | ||
663 | BuiltinType::Float(t) => { | ||
664 | TyKind::Scalar(Scalar::Float(primitive::float_ty_from_builtin(t))).intern(&Interner) | ||
665 | } | ||
627 | } | 666 | } |
628 | } | 667 | } |
629 | 668 | ||
630 | pub fn as_reference(&self) -> Option<(&Ty, Mutability)> { | 669 | pub fn as_reference(&self) -> Option<(&Ty, Mutability)> { |
631 | match self { | 670 | match self.interned(&Interner) { |
632 | Ty::Ref(mutability, parameters) => Some((parameters.as_single(), *mutability)), | 671 | TyKind::Ref(mutability, parameters) => Some((parameters.as_single(), *mutability)), |
633 | _ => None, | 672 | _ => None, |
634 | } | 673 | } |
635 | } | 674 | } |
636 | 675 | ||
637 | pub fn as_reference_or_ptr(&self) -> Option<(&Ty, Rawness, Mutability)> { | 676 | pub fn as_reference_or_ptr(&self) -> Option<(&Ty, Rawness, Mutability)> { |
638 | match self { | 677 | match self.interned(&Interner) { |
639 | Ty::Ref(mutability, parameters) => { | 678 | TyKind::Ref(mutability, parameters) => { |
640 | Some((parameters.as_single(), Rawness::Ref, *mutability)) | 679 | Some((parameters.as_single(), Rawness::Ref, *mutability)) |
641 | } | 680 | } |
642 | Ty::Raw(mutability, parameters) => { | 681 | TyKind::Raw(mutability, parameters) => { |
643 | Some((parameters.as_single(), Rawness::RawPtr, *mutability)) | 682 | Some((parameters.as_single(), Rawness::RawPtr, *mutability)) |
644 | } | 683 | } |
645 | _ => None, | 684 | _ => None, |
@@ -649,7 +688,7 @@ impl Ty { | |||
649 | pub fn strip_references(&self) -> &Ty { | 688 | pub fn strip_references(&self) -> &Ty { |
650 | let mut t: &Ty = self; | 689 | let mut t: &Ty = self; |
651 | 690 | ||
652 | while let Ty::Ref(_mutability, parameters) = t { | 691 | while let TyKind::Ref(_mutability, parameters) = t.interned(&Interner) { |
653 | t = parameters.as_single(); | 692 | t = parameters.as_single(); |
654 | } | 693 | } |
655 | 694 | ||
@@ -657,65 +696,71 @@ impl Ty { | |||
657 | } | 696 | } |
658 | 697 | ||
659 | pub fn as_adt(&self) -> Option<(hir_def::AdtId, &Substs)> { | 698 | pub fn as_adt(&self) -> Option<(hir_def::AdtId, &Substs)> { |
660 | match self { | 699 | match self.interned(&Interner) { |
661 | Ty::Adt(AdtId(adt), parameters) => Some((*adt, parameters)), | 700 | TyKind::Adt(AdtId(adt), parameters) => Some((*adt, parameters)), |
662 | _ => None, | 701 | _ => None, |
663 | } | 702 | } |
664 | } | 703 | } |
665 | 704 | ||
666 | pub fn as_tuple(&self) -> Option<&Substs> { | 705 | pub fn as_tuple(&self) -> Option<&Substs> { |
667 | match self { | 706 | match self.interned(&Interner) { |
668 | Ty::Tuple(_, substs) => Some(substs), | 707 | TyKind::Tuple(_, substs) => Some(substs), |
669 | _ => None, | 708 | _ => None, |
670 | } | 709 | } |
671 | } | 710 | } |
672 | 711 | ||
673 | pub fn as_generic_def(&self) -> Option<GenericDefId> { | 712 | pub fn as_generic_def(&self, db: &dyn HirDatabase) -> Option<GenericDefId> { |
674 | match *self { | 713 | match *self.interned(&Interner) { |
675 | Ty::Adt(AdtId(adt), ..) => Some(adt.into()), | 714 | TyKind::Adt(AdtId(adt), ..) => Some(adt.into()), |
676 | Ty::FnDef(callable, ..) => Some(callable.into()), | 715 | TyKind::FnDef(callable, ..) => { |
677 | Ty::AssociatedType(type_alias, ..) => Some(type_alias.into()), | 716 | Some(db.lookup_intern_callable_def(callable.into()).into()) |
678 | Ty::ForeignType(type_alias, ..) => Some(type_alias.into()), | 717 | } |
718 | TyKind::AssociatedType(type_alias, ..) => Some(from_assoc_type_id(type_alias).into()), | ||
719 | TyKind::ForeignType(type_alias, ..) => Some(from_foreign_def_id(type_alias).into()), | ||
679 | _ => None, | 720 | _ => None, |
680 | } | 721 | } |
681 | } | 722 | } |
682 | 723 | ||
683 | pub fn is_never(&self) -> bool { | 724 | pub fn is_never(&self) -> bool { |
684 | matches!(self, Ty::Never) | 725 | matches!(self.interned(&Interner), TyKind::Never) |
685 | } | 726 | } |
686 | 727 | ||
687 | pub fn is_unknown(&self) -> bool { | 728 | pub fn is_unknown(&self) -> bool { |
688 | matches!(self, Ty::Unknown) | 729 | matches!(self.interned(&Interner), TyKind::Unknown) |
689 | } | 730 | } |
690 | 731 | ||
691 | pub fn equals_ctor(&self, other: &Ty) -> bool { | 732 | pub fn equals_ctor(&self, other: &Ty) -> bool { |
692 | match (self, other) { | 733 | match (self.interned(&Interner), other.interned(&Interner)) { |
693 | (Ty::Adt(adt, ..), Ty::Adt(adt2, ..)) => adt == adt2, | 734 | (TyKind::Adt(adt, ..), TyKind::Adt(adt2, ..)) => adt == adt2, |
694 | (Ty::Slice(_), Ty::Slice(_)) | (Ty::Array(_), Ty::Array(_)) => true, | 735 | (TyKind::Slice(_), TyKind::Slice(_)) | (TyKind::Array(_), TyKind::Array(_)) => true, |
695 | (Ty::FnDef(def_id, ..), Ty::FnDef(def_id2, ..)) => def_id == def_id2, | 736 | (TyKind::FnDef(def_id, ..), TyKind::FnDef(def_id2, ..)) => def_id == def_id2, |
696 | (Ty::OpaqueType(ty_id, ..), Ty::OpaqueType(ty_id2, ..)) => ty_id == ty_id2, | 737 | (TyKind::OpaqueType(ty_id, ..), TyKind::OpaqueType(ty_id2, ..)) => ty_id == ty_id2, |
697 | (Ty::AssociatedType(ty_id, ..), Ty::AssociatedType(ty_id2, ..)) | 738 | (TyKind::AssociatedType(ty_id, ..), TyKind::AssociatedType(ty_id2, ..)) => { |
698 | | (Ty::ForeignType(ty_id, ..), Ty::ForeignType(ty_id2, ..)) => ty_id == ty_id2, | 739 | ty_id == ty_id2 |
699 | (Ty::Closure(def, expr, _), Ty::Closure(def2, expr2, _)) => { | 740 | } |
700 | expr == expr2 && def == def2 | 741 | (TyKind::ForeignType(ty_id, ..), TyKind::ForeignType(ty_id2, ..)) => ty_id == ty_id2, |
742 | (TyKind::Closure(id1, _), TyKind::Closure(id2, _)) => id1 == id2, | ||
743 | (TyKind::Ref(mutability, ..), TyKind::Ref(mutability2, ..)) | ||
744 | | (TyKind::Raw(mutability, ..), TyKind::Raw(mutability2, ..)) => { | ||
745 | mutability == mutability2 | ||
701 | } | 746 | } |
702 | (Ty::Ref(mutability, ..), Ty::Ref(mutability2, ..)) | ||
703 | | (Ty::Raw(mutability, ..), Ty::Raw(mutability2, ..)) => mutability == mutability2, | ||
704 | ( | 747 | ( |
705 | Ty::Function(FnPointer { num_args, sig, .. }), | 748 | TyKind::Function(FnPointer { num_args, sig, .. }), |
706 | Ty::Function(FnPointer { num_args: num_args2, sig: sig2, .. }), | 749 | TyKind::Function(FnPointer { num_args: num_args2, sig: sig2, .. }), |
707 | ) => num_args == num_args2 && sig == sig2, | 750 | ) => num_args == num_args2 && sig == sig2, |
708 | (Ty::Tuple(cardinality, _), Ty::Tuple(cardinality2, _)) => cardinality == cardinality2, | 751 | (TyKind::Tuple(cardinality, _), TyKind::Tuple(cardinality2, _)) => { |
709 | (Ty::Str, Ty::Str) | (Ty::Never, Ty::Never) => true, | 752 | cardinality == cardinality2 |
710 | (Ty::Scalar(scalar), Ty::Scalar(scalar2)) => scalar == scalar2, | 753 | } |
754 | (TyKind::Str, TyKind::Str) | (TyKind::Never, TyKind::Never) => true, | ||
755 | (TyKind::Scalar(scalar), TyKind::Scalar(scalar2)) => scalar == scalar2, | ||
711 | _ => false, | 756 | _ => false, |
712 | } | 757 | } |
713 | } | 758 | } |
714 | 759 | ||
715 | /// If this is a `dyn Trait` type, this returns the `Trait` part. | 760 | /// If this is a `dyn Trait` type, this returns the `Trait` part. |
716 | pub fn dyn_trait_ref(&self) -> Option<&TraitRef> { | 761 | pub fn dyn_trait_ref(&self) -> Option<&TraitRef> { |
717 | match self { | 762 | match self.interned(&Interner) { |
718 | Ty::Dyn(bounds) => bounds.get(0).and_then(|b| match b { | 763 | TyKind::Dyn(bounds) => bounds.get(0).and_then(|b| match b { |
719 | GenericPredicate::Implemented(trait_ref) => Some(trait_ref), | 764 | GenericPredicate::Implemented(trait_ref) => Some(trait_ref), |
720 | _ => None, | 765 | _ => None, |
721 | }), | 766 | }), |
@@ -729,28 +774,37 @@ impl Ty { | |||
729 | } | 774 | } |
730 | 775 | ||
731 | fn builtin_deref(&self) -> Option<Ty> { | 776 | fn builtin_deref(&self) -> Option<Ty> { |
732 | match self { | 777 | match self.interned(&Interner) { |
733 | Ty::Ref(.., parameters) => Some(Ty::clone(parameters.as_single())), | 778 | TyKind::Ref(.., parameters) => Some(Ty::clone(parameters.as_single())), |
734 | Ty::Raw(.., parameters) => Some(Ty::clone(parameters.as_single())), | 779 | TyKind::Raw(.., parameters) => Some(Ty::clone(parameters.as_single())), |
735 | _ => None, | 780 | _ => None, |
736 | } | 781 | } |
737 | } | 782 | } |
738 | 783 | ||
739 | pub fn as_fn_def(&self) -> Option<FunctionId> { | 784 | pub fn callable_def(&self, db: &dyn HirDatabase) -> Option<CallableDefId> { |
740 | match self { | 785 | match self.interned(&Interner) { |
741 | &Ty::FnDef(CallableDefId::FunctionId(func), ..) => Some(func), | 786 | &TyKind::FnDef(def, ..) => Some(db.lookup_intern_callable_def(def.into())), |
742 | _ => None, | 787 | _ => None, |
743 | } | 788 | } |
744 | } | 789 | } |
745 | 790 | ||
791 | pub fn as_fn_def(&self, db: &dyn HirDatabase) -> Option<FunctionId> { | ||
792 | if let Some(CallableDefId::FunctionId(func)) = self.callable_def(db) { | ||
793 | Some(func) | ||
794 | } else { | ||
795 | None | ||
796 | } | ||
797 | } | ||
798 | |||
746 | pub fn callable_sig(&self, db: &dyn HirDatabase) -> Option<CallableSig> { | 799 | pub fn callable_sig(&self, db: &dyn HirDatabase) -> Option<CallableSig> { |
747 | match self { | 800 | match self.interned(&Interner) { |
748 | Ty::Function(fn_ptr) => Some(CallableSig::from_fn_ptr(fn_ptr)), | 801 | TyKind::Function(fn_ptr) => Some(CallableSig::from_fn_ptr(fn_ptr)), |
749 | Ty::FnDef(def, parameters) => { | 802 | TyKind::FnDef(def, parameters) => { |
750 | let sig = db.callable_item_signature(*def); | 803 | let callable_def = db.lookup_intern_callable_def((*def).into()); |
804 | let sig = db.callable_item_signature(callable_def); | ||
751 | Some(sig.subst(¶meters)) | 805 | Some(sig.subst(¶meters)) |
752 | } | 806 | } |
753 | Ty::Closure(.., substs) => { | 807 | TyKind::Closure(.., substs) => { |
754 | let sig_param = &substs[0]; | 808 | let sig_param = &substs[0]; |
755 | sig_param.callable_sig(db) | 809 | sig_param.callable_sig(db) |
756 | } | 810 | } |
@@ -763,18 +817,18 @@ impl Ty { | |||
763 | /// `self` is `Option<_>` and the substs contain `u32`, we'll have | 817 | /// `self` is `Option<_>` and the substs contain `u32`, we'll have |
764 | /// `Option<u32>` afterwards.) | 818 | /// `Option<u32>` afterwards.) |
765 | pub fn apply_substs(mut self, new_substs: Substs) -> Ty { | 819 | pub fn apply_substs(mut self, new_substs: Substs) -> Ty { |
766 | match &mut self { | 820 | match &mut self.0 { |
767 | Ty::Adt(_, substs) | 821 | TyKind::Adt(_, substs) |
768 | | Ty::Slice(substs) | 822 | | TyKind::Slice(substs) |
769 | | Ty::Array(substs) | 823 | | TyKind::Array(substs) |
770 | | Ty::Raw(_, substs) | 824 | | TyKind::Raw(_, substs) |
771 | | Ty::Ref(_, substs) | 825 | | TyKind::Ref(_, substs) |
772 | | Ty::FnDef(_, substs) | 826 | | TyKind::FnDef(_, substs) |
773 | | Ty::Function(FnPointer { substs, .. }) | 827 | | TyKind::Function(FnPointer { substs, .. }) |
774 | | Ty::Tuple(_, substs) | 828 | | TyKind::Tuple(_, substs) |
775 | | Ty::OpaqueType(_, substs) | 829 | | TyKind::OpaqueType(_, substs) |
776 | | Ty::AssociatedType(_, substs) | 830 | | TyKind::AssociatedType(_, substs) |
777 | | Ty::Closure(.., substs) => { | 831 | | TyKind::Closure(.., substs) => { |
778 | assert_eq!(substs.len(), new_substs.len()); | 832 | assert_eq!(substs.len(), new_substs.len()); |
779 | *substs = new_substs; | 833 | *substs = new_substs; |
780 | } | 834 | } |
@@ -786,44 +840,44 @@ impl Ty { | |||
786 | /// Returns the type parameters of this type if it has some (i.e. is an ADT | 840 | /// Returns the type parameters of this type if it has some (i.e. is an ADT |
787 | /// or function); so if `self` is `Option<u32>`, this returns the `u32`. | 841 | /// or function); so if `self` is `Option<u32>`, this returns the `u32`. |
788 | pub fn substs(&self) -> Option<&Substs> { | 842 | pub fn substs(&self) -> Option<&Substs> { |
789 | match self { | 843 | match self.interned(&Interner) { |
790 | Ty::Adt(_, substs) | 844 | TyKind::Adt(_, substs) |
791 | | Ty::Slice(substs) | 845 | | TyKind::Slice(substs) |
792 | | Ty::Array(substs) | 846 | | TyKind::Array(substs) |
793 | | Ty::Raw(_, substs) | 847 | | TyKind::Raw(_, substs) |
794 | | Ty::Ref(_, substs) | 848 | | TyKind::Ref(_, substs) |
795 | | Ty::FnDef(_, substs) | 849 | | TyKind::FnDef(_, substs) |
796 | | Ty::Function(FnPointer { substs, .. }) | 850 | | TyKind::Function(FnPointer { substs, .. }) |
797 | | Ty::Tuple(_, substs) | 851 | | TyKind::Tuple(_, substs) |
798 | | Ty::OpaqueType(_, substs) | 852 | | TyKind::OpaqueType(_, substs) |
799 | | Ty::AssociatedType(_, substs) | 853 | | TyKind::AssociatedType(_, substs) |
800 | | Ty::Closure(.., substs) => Some(substs), | 854 | | TyKind::Closure(.., substs) => Some(substs), |
801 | _ => None, | 855 | _ => None, |
802 | } | 856 | } |
803 | } | 857 | } |
804 | 858 | ||
805 | pub fn substs_mut(&mut self) -> Option<&mut Substs> { | 859 | pub fn substs_mut(&mut self) -> Option<&mut Substs> { |
806 | match self { | 860 | match &mut self.0 { |
807 | Ty::Adt(_, substs) | 861 | TyKind::Adt(_, substs) |
808 | | Ty::Slice(substs) | 862 | | TyKind::Slice(substs) |
809 | | Ty::Array(substs) | 863 | | TyKind::Array(substs) |
810 | | Ty::Raw(_, substs) | 864 | | TyKind::Raw(_, substs) |
811 | | Ty::Ref(_, substs) | 865 | | TyKind::Ref(_, substs) |
812 | | Ty::FnDef(_, substs) | 866 | | TyKind::FnDef(_, substs) |
813 | | Ty::Function(FnPointer { substs, .. }) | 867 | | TyKind::Function(FnPointer { substs, .. }) |
814 | | Ty::Tuple(_, substs) | 868 | | TyKind::Tuple(_, substs) |
815 | | Ty::OpaqueType(_, substs) | 869 | | TyKind::OpaqueType(_, substs) |
816 | | Ty::AssociatedType(_, substs) | 870 | | TyKind::AssociatedType(_, substs) |
817 | | Ty::Closure(.., substs) => Some(substs), | 871 | | TyKind::Closure(.., substs) => Some(substs), |
818 | _ => None, | 872 | _ => None, |
819 | } | 873 | } |
820 | } | 874 | } |
821 | 875 | ||
822 | pub fn impl_trait_bounds(&self, db: &dyn HirDatabase) -> Option<Vec<GenericPredicate>> { | 876 | pub fn impl_trait_bounds(&self, db: &dyn HirDatabase) -> Option<Vec<GenericPredicate>> { |
823 | match self { | 877 | match self.interned(&Interner) { |
824 | Ty::OpaqueType(opaque_ty_id, ..) => { | 878 | TyKind::OpaqueType(opaque_ty_id, ..) => { |
825 | match opaque_ty_id { | 879 | match db.lookup_intern_impl_trait_id((*opaque_ty_id).into()) { |
826 | OpaqueTyId::AsyncBlockTypeImplTrait(def, _expr) => { | 880 | ImplTraitId::AsyncBlockTypeImplTrait(def, _expr) => { |
827 | let krate = def.module(db.upcast()).krate(); | 881 | let krate = def.module(db.upcast()).krate(); |
828 | if let Some(future_trait) = db | 882 | if let Some(future_trait) = db |
829 | .lang_item(krate, "future_trait".into()) | 883 | .lang_item(krate, "future_trait".into()) |
@@ -841,12 +895,13 @@ impl Ty { | |||
841 | None | 895 | None |
842 | } | 896 | } |
843 | } | 897 | } |
844 | OpaqueTyId::ReturnTypeImplTrait(..) => None, | 898 | ImplTraitId::ReturnTypeImplTrait(..) => None, |
845 | } | 899 | } |
846 | } | 900 | } |
847 | Ty::Alias(AliasTy::Opaque(opaque_ty)) => { | 901 | TyKind::Alias(AliasTy::Opaque(opaque_ty)) => { |
848 | let predicates = match opaque_ty.opaque_ty_id { | 902 | let predicates = match db.lookup_intern_impl_trait_id(opaque_ty.opaque_ty_id.into()) |
849 | OpaqueTyId::ReturnTypeImplTrait(func, idx) => { | 903 | { |
904 | ImplTraitId::ReturnTypeImplTrait(func, idx) => { | ||
850 | db.return_type_impl_traits(func).map(|it| { | 905 | db.return_type_impl_traits(func).map(|it| { |
851 | let data = (*it) | 906 | let data = (*it) |
852 | .as_ref() | 907 | .as_ref() |
@@ -855,18 +910,19 @@ impl Ty { | |||
855 | }) | 910 | }) |
856 | } | 911 | } |
857 | // It always has an parameter for Future::Output type. | 912 | // It always has an parameter for Future::Output type. |
858 | OpaqueTyId::AsyncBlockTypeImplTrait(..) => unreachable!(), | 913 | ImplTraitId::AsyncBlockTypeImplTrait(..) => unreachable!(), |
859 | }; | 914 | }; |
860 | 915 | ||
861 | predicates.map(|it| it.value) | 916 | predicates.map(|it| it.value) |
862 | } | 917 | } |
863 | Ty::Placeholder(id) => { | 918 | TyKind::Placeholder(idx) => { |
919 | let id = from_placeholder_idx(db, *idx); | ||
864 | let generic_params = db.generic_params(id.parent); | 920 | let generic_params = db.generic_params(id.parent); |
865 | let param_data = &generic_params.types[id.local_id]; | 921 | let param_data = &generic_params.types[id.local_id]; |
866 | match param_data.provenance { | 922 | match param_data.provenance { |
867 | hir_def::generics::TypeParamProvenance::ArgumentImplTrait => { | 923 | hir_def::generics::TypeParamProvenance::ArgumentImplTrait => { |
868 | let predicates = db | 924 | let predicates = db |
869 | .generic_predicates_for_param(*id) | 925 | .generic_predicates_for_param(id) |
870 | .into_iter() | 926 | .into_iter() |
871 | .map(|pred| pred.value.clone()) | 927 | .map(|pred| pred.value.clone()) |
872 | .collect_vec(); | 928 | .collect_vec(); |
@@ -881,15 +937,16 @@ impl Ty { | |||
881 | } | 937 | } |
882 | 938 | ||
883 | pub fn associated_type_parent_trait(&self, db: &dyn HirDatabase) -> Option<TraitId> { | 939 | pub fn associated_type_parent_trait(&self, db: &dyn HirDatabase) -> Option<TraitId> { |
884 | match self { | 940 | match self.interned(&Interner) { |
885 | Ty::AssociatedType(type_alias_id, ..) => { | 941 | TyKind::AssociatedType(id, ..) => { |
886 | match type_alias_id.lookup(db.upcast()).container { | 942 | match from_assoc_type_id(*id).lookup(db.upcast()).container { |
887 | AssocContainerId::TraitId(trait_id) => Some(trait_id), | 943 | AssocContainerId::TraitId(trait_id) => Some(trait_id), |
888 | _ => None, | 944 | _ => None, |
889 | } | 945 | } |
890 | } | 946 | } |
891 | Ty::Alias(AliasTy::Projection(projection_ty)) => { | 947 | TyKind::Alias(AliasTy::Projection(projection_ty)) => { |
892 | match projection_ty.associated_ty.lookup(db.upcast()).container { | 948 | match from_assoc_type_id(projection_ty.associated_ty).lookup(db.upcast()).container |
949 | { | ||
893 | AssocContainerId::TraitId(trait_id) => Some(trait_id), | 950 | AssocContainerId::TraitId(trait_id) => Some(trait_id), |
894 | _ => None, | 951 | _ => None, |
895 | } | 952 | } |
@@ -908,13 +965,13 @@ pub trait TypeWalk { | |||
908 | } | 965 | } |
909 | /// Walk the type, counting entered binders. | 966 | /// Walk the type, counting entered binders. |
910 | /// | 967 | /// |
911 | /// `Ty::Bound` variables use DeBruijn indexing, which means that 0 refers | 968 | /// `TyKind::Bound` variables use DeBruijn indexing, which means that 0 refers |
912 | /// to the innermost binder, 1 to the next, etc.. So when we want to | 969 | /// to the innermost binder, 1 to the next, etc.. So when we want to |
913 | /// substitute a certain bound variable, we can't just walk the whole type | 970 | /// substitute a certain bound variable, we can't just walk the whole type |
914 | /// and blindly replace each instance of a certain index; when we 'enter' | 971 | /// and blindly replace each instance of a certain index; when we 'enter' |
915 | /// things that introduce new bound variables, we have to keep track of | 972 | /// things that introduce new bound variables, we have to keep track of |
916 | /// that. Currently, the only thing that introduces bound variables on our | 973 | /// that. Currently, the only thing that introduces bound variables on our |
917 | /// side are `Ty::Dyn` and `Ty::Opaque`, which each introduce a bound | 974 | /// side are `TyKind::Dyn` and `TyKind::Opaque`, which each introduce a bound |
918 | /// variable for the self type. | 975 | /// variable for the self type. |
919 | fn walk_mut_binders( | 976 | fn walk_mut_binders( |
920 | &mut self, | 977 | &mut self, |
@@ -932,7 +989,7 @@ pub trait TypeWalk { | |||
932 | { | 989 | { |
933 | self.walk_mut_binders( | 990 | self.walk_mut_binders( |
934 | &mut |ty_mut, binders| { | 991 | &mut |ty_mut, binders| { |
935 | let ty = mem::replace(ty_mut, Ty::Unknown); | 992 | let ty = mem::replace(ty_mut, Ty(TyKind::Unknown)); |
936 | *ty_mut = f(ty, binders); | 993 | *ty_mut = f(ty, binders); |
937 | }, | 994 | }, |
938 | binders, | 995 | binders, |
@@ -945,13 +1002,13 @@ pub trait TypeWalk { | |||
945 | Self: Sized, | 1002 | Self: Sized, |
946 | { | 1003 | { |
947 | self.walk_mut(&mut |ty_mut| { | 1004 | self.walk_mut(&mut |ty_mut| { |
948 | let ty = mem::replace(ty_mut, Ty::Unknown); | 1005 | let ty = mem::replace(ty_mut, Ty(TyKind::Unknown)); |
949 | *ty_mut = f(ty); | 1006 | *ty_mut = f(ty); |
950 | }); | 1007 | }); |
951 | self | 1008 | self |
952 | } | 1009 | } |
953 | 1010 | ||
954 | /// Substitutes `Ty::Bound` vars with the given substitution. | 1011 | /// Substitutes `TyKind::Bound` vars with the given substitution. |
955 | fn subst_bound_vars(self, substs: &Substs) -> Self | 1012 | fn subst_bound_vars(self, substs: &Substs) -> Self |
956 | where | 1013 | where |
957 | Self: Sized, | 1014 | Self: Sized, |
@@ -959,14 +1016,14 @@ pub trait TypeWalk { | |||
959 | self.subst_bound_vars_at_depth(substs, DebruijnIndex::INNERMOST) | 1016 | self.subst_bound_vars_at_depth(substs, DebruijnIndex::INNERMOST) |
960 | } | 1017 | } |
961 | 1018 | ||
962 | /// Substitutes `Ty::Bound` vars with the given substitution. | 1019 | /// Substitutes `TyKind::Bound` vars with the given substitution. |
963 | fn subst_bound_vars_at_depth(mut self, substs: &Substs, depth: DebruijnIndex) -> Self | 1020 | fn subst_bound_vars_at_depth(mut self, substs: &Substs, depth: DebruijnIndex) -> Self |
964 | where | 1021 | where |
965 | Self: Sized, | 1022 | Self: Sized, |
966 | { | 1023 | { |
967 | self.walk_mut_binders( | 1024 | self.walk_mut_binders( |
968 | &mut |ty, binders| { | 1025 | &mut |ty, binders| { |
969 | if let &mut Ty::BoundVar(bound) = ty { | 1026 | if let &mut TyKind::BoundVar(bound) = &mut ty.0 { |
970 | if bound.debruijn >= binders { | 1027 | if bound.debruijn >= binders { |
971 | *ty = substs.0[bound.index].clone().shift_bound_vars(binders); | 1028 | *ty = substs.0[bound.index].clone().shift_bound_vars(binders); |
972 | } | 1029 | } |
@@ -977,17 +1034,17 @@ pub trait TypeWalk { | |||
977 | self | 1034 | self |
978 | } | 1035 | } |
979 | 1036 | ||
980 | /// Shifts up debruijn indices of `Ty::Bound` vars by `n`. | 1037 | /// Shifts up debruijn indices of `TyKind::Bound` vars by `n`. |
981 | fn shift_bound_vars(self, n: DebruijnIndex) -> Self | 1038 | fn shift_bound_vars(self, n: DebruijnIndex) -> Self |
982 | where | 1039 | where |
983 | Self: Sized, | 1040 | Self: Sized, |
984 | { | 1041 | { |
985 | self.fold_binders( | 1042 | self.fold_binders( |
986 | &mut |ty, binders| match ty { | 1043 | &mut |ty, binders| match &ty.0 { |
987 | Ty::BoundVar(bound) if bound.debruijn >= binders => { | 1044 | TyKind::BoundVar(bound) if bound.debruijn >= binders => { |
988 | Ty::BoundVar(bound.shifted_in_from(n)) | 1045 | TyKind::BoundVar(bound.shifted_in_from(n)).intern(&Interner) |
989 | } | 1046 | } |
990 | ty => ty, | 1047 | _ => ty, |
991 | }, | 1048 | }, |
992 | DebruijnIndex::INNERMOST, | 1049 | DebruijnIndex::INNERMOST, |
993 | ) | 1050 | ) |
@@ -996,18 +1053,18 @@ pub trait TypeWalk { | |||
996 | 1053 | ||
997 | impl TypeWalk for Ty { | 1054 | impl TypeWalk for Ty { |
998 | fn walk(&self, f: &mut impl FnMut(&Ty)) { | 1055 | fn walk(&self, f: &mut impl FnMut(&Ty)) { |
999 | match self { | 1056 | match self.interned(&Interner) { |
1000 | Ty::Alias(AliasTy::Projection(p_ty)) => { | 1057 | TyKind::Alias(AliasTy::Projection(p_ty)) => { |
1001 | for t in p_ty.parameters.iter() { | 1058 | for t in p_ty.parameters.iter() { |
1002 | t.walk(f); | 1059 | t.walk(f); |
1003 | } | 1060 | } |
1004 | } | 1061 | } |
1005 | Ty::Alias(AliasTy::Opaque(o_ty)) => { | 1062 | TyKind::Alias(AliasTy::Opaque(o_ty)) => { |
1006 | for t in o_ty.parameters.iter() { | 1063 | for t in o_ty.parameters.iter() { |
1007 | t.walk(f); | 1064 | t.walk(f); |
1008 | } | 1065 | } |
1009 | } | 1066 | } |
1010 | Ty::Dyn(predicates) => { | 1067 | TyKind::Dyn(predicates) => { |
1011 | for p in predicates.iter() { | 1068 | for p in predicates.iter() { |
1012 | p.walk(f); | 1069 | p.walk(f); |
1013 | } | 1070 | } |
@@ -1028,16 +1085,16 @@ impl TypeWalk for Ty { | |||
1028 | f: &mut impl FnMut(&mut Ty, DebruijnIndex), | 1085 | f: &mut impl FnMut(&mut Ty, DebruijnIndex), |
1029 | binders: DebruijnIndex, | 1086 | binders: DebruijnIndex, |
1030 | ) { | 1087 | ) { |
1031 | match self { | 1088 | match &mut self.0 { |
1032 | Ty::Alias(AliasTy::Projection(p_ty)) => { | 1089 | TyKind::Alias(AliasTy::Projection(p_ty)) => { |
1033 | p_ty.parameters.walk_mut_binders(f, binders); | 1090 | p_ty.parameters.walk_mut_binders(f, binders); |
1034 | } | 1091 | } |
1035 | Ty::Dyn(predicates) => { | 1092 | TyKind::Dyn(predicates) => { |
1036 | for p in make_mut_slice(predicates) { | 1093 | for p in make_mut_slice(predicates) { |
1037 | p.walk_mut_binders(f, binders.shifted_in()); | 1094 | p.walk_mut_binders(f, binders.shifted_in()); |
1038 | } | 1095 | } |
1039 | } | 1096 | } |
1040 | Ty::Alias(AliasTy::Opaque(o_ty)) => { | 1097 | TyKind::Alias(AliasTy::Opaque(o_ty)) => { |
1041 | o_ty.parameters.walk_mut_binders(f, binders); | 1098 | o_ty.parameters.walk_mut_binders(f, binders); |
1042 | } | 1099 | } |
1043 | _ => { | 1100 | _ => { |
@@ -1068,7 +1125,7 @@ impl<T: TypeWalk> TypeWalk for Vec<T> { | |||
1068 | } | 1125 | } |
1069 | 1126 | ||
1070 | #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)] | 1127 | #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)] |
1071 | pub enum OpaqueTyId { | 1128 | pub enum ImplTraitId { |
1072 | ReturnTypeImplTrait(hir_def::FunctionId, u16), | 1129 | ReturnTypeImplTrait(hir_def::FunctionId, u16), |
1073 | AsyncBlockTypeImplTrait(hir_def::DefWithBodyId, ExprId), | 1130 | AsyncBlockTypeImplTrait(hir_def::DefWithBodyId, ExprId), |
1074 | } | 1131 | } |
@@ -1082,3 +1139,33 @@ pub struct ReturnTypeImplTraits { | |||
1082 | pub(crate) struct ReturnTypeImplTrait { | 1139 | pub(crate) struct ReturnTypeImplTrait { |
1083 | pub(crate) bounds: Binders<Vec<GenericPredicate>>, | 1140 | pub(crate) bounds: Binders<Vec<GenericPredicate>>, |
1084 | } | 1141 | } |
1142 | |||
1143 | pub fn to_foreign_def_id(id: TypeAliasId) -> ForeignDefId { | ||
1144 | chalk_ir::ForeignDefId(salsa::InternKey::as_intern_id(&id)) | ||
1145 | } | ||
1146 | |||
1147 | pub fn from_foreign_def_id(id: ForeignDefId) -> TypeAliasId { | ||
1148 | salsa::InternKey::from_intern_id(id.0) | ||
1149 | } | ||
1150 | |||
1151 | pub fn to_assoc_type_id(id: TypeAliasId) -> AssocTypeId { | ||
1152 | chalk_ir::AssocTypeId(salsa::InternKey::as_intern_id(&id)) | ||
1153 | } | ||
1154 | |||
1155 | pub fn from_assoc_type_id(id: AssocTypeId) -> TypeAliasId { | ||
1156 | salsa::InternKey::from_intern_id(id.0) | ||
1157 | } | ||
1158 | |||
1159 | pub fn from_placeholder_idx(db: &dyn HirDatabase, idx: PlaceholderIndex) -> TypeParamId { | ||
1160 | assert_eq!(idx.ui, chalk_ir::UniverseIndex::ROOT); | ||
1161 | let interned_id = salsa::InternKey::from_intern_id(salsa::InternId::from(idx.idx)); | ||
1162 | db.lookup_intern_type_param_id(interned_id) | ||
1163 | } | ||
1164 | |||
1165 | pub fn to_placeholder_idx(db: &dyn HirDatabase, id: TypeParamId) -> PlaceholderIndex { | ||
1166 | let interned_id = db.intern_type_param_id(id); | ||
1167 | PlaceholderIndex { | ||
1168 | ui: chalk_ir::UniverseIndex::ROOT, | ||
1169 | idx: salsa::InternKey::as_intern_id(&interned_id).as_usize(), | ||
1170 | } | ||
1171 | } | ||
diff --git a/crates/hir_ty/src/lower.rs b/crates/hir_ty/src/lower.rs index d84ec9b7a..c32dca9d7 100644 --- a/crates/hir_ty/src/lower.rs +++ b/crates/hir_ty/src/lower.rs | |||
@@ -27,14 +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, | ||
30 | traits::chalk::{Interner, ToChalk}, | 31 | traits::chalk::{Interner, ToChalk}, |
31 | utils::{ | 32 | utils::{ |
32 | 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, |
33 | make_mut_slice, variant_data, | 34 | make_mut_slice, variant_data, |
34 | }, | 35 | }, |
35 | AliasTy, Binders, BoundVar, CallableSig, DebruijnIndex, FnPointer, FnSig, GenericPredicate, | 36 | AliasTy, Binders, BoundVar, CallableSig, DebruijnIndex, FnPointer, FnSig, GenericPredicate, |
36 | OpaqueTy, OpaqueTyId, PolyFnSig, ProjectionPredicate, ProjectionTy, ReturnTypeImplTrait, | 37 | ImplTraitId, OpaqueTy, PolyFnSig, ProjectionPredicate, ProjectionTy, ReturnTypeImplTrait, |
37 | ReturnTypeImplTraits, Substs, TraitEnvironment, TraitRef, Ty, TypeWalk, | 38 | ReturnTypeImplTraits, Substs, TraitEnvironment, TraitRef, Ty, TyKind, TypeWalk, |
38 | }; | 39 | }; |
39 | 40 | ||
40 | #[derive(Debug)] | 41 | #[derive(Debug)] |
@@ -139,69 +140,71 @@ pub enum TypeParamLoweringMode { | |||
139 | Variable, | 140 | Variable, |
140 | } | 141 | } |
141 | 142 | ||
142 | impl Ty { | 143 | impl<'a> TyLoweringContext<'a> { |
143 | pub fn from_hir(ctx: &TyLoweringContext<'_>, type_ref: &TypeRef) -> Self { | 144 | pub fn lower_ty(&self, type_ref: &TypeRef) -> Ty { |
144 | Ty::from_hir_ext(ctx, type_ref).0 | 145 | self.lower_ty_ext(type_ref).0 |
145 | } | 146 | } |
146 | 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>) { | ||
147 | let mut res = None; | 149 | let mut res = None; |
148 | let ty = match type_ref { | 150 | let ty = match type_ref { |
149 | TypeRef::Never => Ty::Never, | 151 | TypeRef::Never => TyKind::Never.intern(&Interner), |
150 | TypeRef::Tuple(inner) => { | 152 | TypeRef::Tuple(inner) => { |
151 | 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(); |
152 | Ty::Tuple(inner_tys.len(), Substs(inner_tys)) | 154 | TyKind::Tuple(inner_tys.len(), Substs(inner_tys)).intern(&Interner) |
153 | } | 155 | } |
154 | TypeRef::Path(path) => { | 156 | TypeRef::Path(path) => { |
155 | let (ty, res_) = Ty::from_hir_path(ctx, path); | 157 | let (ty, res_) = self.lower_path(path); |
156 | res = res_; | 158 | res = res_; |
157 | ty | 159 | ty |
158 | } | 160 | } |
159 | TypeRef::RawPtr(inner, mutability) => { | 161 | TypeRef::RawPtr(inner, mutability) => { |
160 | let inner_ty = Ty::from_hir(ctx, inner); | 162 | let inner_ty = self.lower_ty(inner); |
161 | 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) | ||
162 | } | 165 | } |
163 | TypeRef::Array(inner) => { | 166 | TypeRef::Array(inner) => { |
164 | let inner_ty = Ty::from_hir(ctx, inner); | 167 | let inner_ty = self.lower_ty(inner); |
165 | Ty::Array(Substs::single(inner_ty)) | 168 | TyKind::Array(Substs::single(inner_ty)).intern(&Interner) |
166 | } | 169 | } |
167 | TypeRef::Slice(inner) => { | 170 | TypeRef::Slice(inner) => { |
168 | let inner_ty = Ty::from_hir(ctx, inner); | 171 | let inner_ty = self.lower_ty(inner); |
169 | Ty::Slice(Substs::single(inner_ty)) | 172 | TyKind::Slice(Substs::single(inner_ty)).intern(&Interner) |
170 | } | 173 | } |
171 | TypeRef::Reference(inner, _, mutability) => { | 174 | TypeRef::Reference(inner, _, mutability) => { |
172 | let inner_ty = Ty::from_hir(ctx, inner); | 175 | let inner_ty = self.lower_ty(inner); |
173 | 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) | ||
174 | } | 178 | } |
175 | TypeRef::Placeholder => Ty::Unknown, | 179 | TypeRef::Placeholder => TyKind::Unknown.intern(&Interner), |
176 | TypeRef::Fn(params, is_varargs) => { | 180 | TypeRef::Fn(params, is_varargs) => { |
177 | 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()); |
178 | Ty::Function(FnPointer { | 182 | TyKind::Function(FnPointer { |
179 | num_args: substs.len() - 1, | 183 | num_args: substs.len() - 1, |
180 | sig: FnSig { variadic: *is_varargs }, | 184 | sig: FnSig { variadic: *is_varargs }, |
181 | substs, | 185 | substs, |
182 | }) | 186 | }) |
187 | .intern(&Interner) | ||
183 | } | 188 | } |
184 | TypeRef::DynTrait(bounds) => { | 189 | TypeRef::DynTrait(bounds) => { |
185 | let self_ty = Ty::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0)); | 190 | let self_ty = |
186 | let predicates = ctx.with_shifted_in(DebruijnIndex::ONE, |ctx| { | 191 | TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0)).intern(&Interner); |
187 | bounds | 192 | let predicates = self.with_shifted_in(DebruijnIndex::ONE, |ctx| { |
188 | .iter() | 193 | bounds.iter().flat_map(|b| ctx.lower_type_bound(b, self_ty.clone())).collect() |
189 | .flat_map(|b| GenericPredicate::from_type_bound(ctx, b, self_ty.clone())) | ||
190 | .collect() | ||
191 | }); | 194 | }); |
192 | Ty::Dyn(predicates) | 195 | TyKind::Dyn(predicates).intern(&Interner) |
193 | } | 196 | } |
194 | TypeRef::ImplTrait(bounds) => { | 197 | TypeRef::ImplTrait(bounds) => { |
195 | match ctx.impl_trait_mode { | 198 | match self.impl_trait_mode { |
196 | ImplTraitLoweringMode::Opaque => { | 199 | ImplTraitLoweringMode::Opaque => { |
197 | let idx = ctx.impl_trait_counter.get(); | 200 | let idx = self.impl_trait_counter.get(); |
198 | ctx.impl_trait_counter.set(idx + 1); | 201 | self.impl_trait_counter.set(idx + 1); |
199 | 202 | ||
200 | assert!(idx as usize == ctx.opaque_type_data.borrow().len()); | 203 | assert!(idx as usize == self.opaque_type_data.borrow().len()); |
201 | // 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 |
202 | // place even if we encounter more opaque types while | 205 | // place even if we encounter more opaque types while |
203 | // lowering the bounds | 206 | // lowering the bounds |
204 | ctx.opaque_type_data | 207 | self.opaque_type_data |
205 | .borrow_mut() | 208 | .borrow_mut() |
206 | .push(ReturnTypeImplTrait { bounds: Binders::new(1, Vec::new()) }); | 209 | .push(ReturnTypeImplTrait { bounds: Binders::new(1, Vec::new()) }); |
207 | // We don't want to lower the bounds inside the binders | 210 | // We don't want to lower the bounds inside the binders |
@@ -213,65 +216,67 @@ impl Ty { | |||
213 | // other, but separately. So if the `T` refers to a type | 216 | // other, but separately. So if the `T` refers to a type |
214 | // parameter of the outer function, it's just one binder | 217 | // parameter of the outer function, it's just one binder |
215 | // away instead of two. | 218 | // away instead of two. |
216 | let actual_opaque_type_data = ctx | 219 | let actual_opaque_type_data = self |
217 | .with_debruijn(DebruijnIndex::INNERMOST, |ctx| { | 220 | .with_debruijn(DebruijnIndex::INNERMOST, |ctx| { |
218 | ReturnTypeImplTrait::from_hir(ctx, &bounds) | 221 | ctx.lower_impl_trait(&bounds) |
219 | }); | 222 | }); |
220 | 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; |
221 | 224 | ||
222 | let func = match ctx.resolver.generic_def() { | 225 | let func = match self.resolver.generic_def() { |
223 | Some(GenericDefId::FunctionId(f)) => f, | 226 | Some(GenericDefId::FunctionId(f)) => f, |
224 | _ => panic!("opaque impl trait lowering in non-function"), | 227 | _ => panic!("opaque impl trait lowering in non-function"), |
225 | }; | 228 | }; |
226 | let impl_trait_id = OpaqueTyId::ReturnTypeImplTrait(func, idx); | 229 | let impl_trait_id = ImplTraitId::ReturnTypeImplTrait(func, idx); |
227 | let generics = generics(ctx.db.upcast(), func.into()); | 230 | let opaque_ty_id = self.db.intern_impl_trait_id(impl_trait_id).into(); |
228 | let parameters = Substs::bound_vars(&generics, ctx.in_binders); | 231 | let generics = generics(self.db.upcast(), func.into()); |
229 | Ty::Alias(AliasTy::Opaque(OpaqueTy { | 232 | let parameters = Substs::bound_vars(&generics, self.in_binders); |
230 | opaque_ty_id: impl_trait_id, | 233 | TyKind::Alias(AliasTy::Opaque(OpaqueTy { opaque_ty_id, parameters })) |
231 | parameters, | 234 | .intern(&Interner) |
232 | })) | ||
233 | } | 235 | } |
234 | ImplTraitLoweringMode::Param => { | 236 | ImplTraitLoweringMode::Param => { |
235 | let idx = ctx.impl_trait_counter.get(); | 237 | let idx = self.impl_trait_counter.get(); |
236 | // FIXME we're probably doing something wrong here | 238 | // FIXME we're probably doing something wrong here |
237 | ctx.impl_trait_counter.set(idx + count_impl_traits(type_ref) as u16); | 239 | self.impl_trait_counter.set(idx + count_impl_traits(type_ref) as u16); |
238 | if let Some(def) = ctx.resolver.generic_def() { | 240 | if let Some(def) = self.resolver.generic_def() { |
239 | let generics = generics(ctx.db.upcast(), def); | 241 | let generics = generics(self.db.upcast(), def); |
240 | let param = generics | 242 | let param = generics |
241 | .iter() | 243 | .iter() |
242 | .filter(|(_, data)| { | 244 | .filter(|(_, data)| { |
243 | data.provenance == TypeParamProvenance::ArgumentImplTrait | 245 | data.provenance == TypeParamProvenance::ArgumentImplTrait |
244 | }) | 246 | }) |
245 | .nth(idx as usize) | 247 | .nth(idx as usize) |
246 | .map_or(Ty::Unknown, |(id, _)| Ty::Placeholder(id)); | 248 | .map_or(TyKind::Unknown, |(id, _)| { |
247 | param | 249 | TyKind::Placeholder(to_placeholder_idx(self.db, id)) |
250 | }); | ||
251 | param.intern(&Interner) | ||
248 | } else { | 252 | } else { |
249 | Ty::Unknown | 253 | TyKind::Unknown.intern(&Interner) |
250 | } | 254 | } |
251 | } | 255 | } |
252 | ImplTraitLoweringMode::Variable => { | 256 | ImplTraitLoweringMode::Variable => { |
253 | let idx = ctx.impl_trait_counter.get(); | 257 | let idx = self.impl_trait_counter.get(); |
254 | // FIXME we're probably doing something wrong here | 258 | // FIXME we're probably doing something wrong here |
255 | ctx.impl_trait_counter.set(idx + count_impl_traits(type_ref) as u16); | 259 | self.impl_trait_counter.set(idx + count_impl_traits(type_ref) as u16); |
256 | let (parent_params, self_params, list_params, _impl_trait_params) = | 260 | let (parent_params, self_params, list_params, _impl_trait_params) = |
257 | if let Some(def) = ctx.resolver.generic_def() { | 261 | if let Some(def) = self.resolver.generic_def() { |
258 | let generics = generics(ctx.db.upcast(), def); | 262 | let generics = generics(self.db.upcast(), def); |
259 | generics.provenance_split() | 263 | generics.provenance_split() |
260 | } else { | 264 | } else { |
261 | (0, 0, 0, 0) | 265 | (0, 0, 0, 0) |
262 | }; | 266 | }; |
263 | Ty::BoundVar(BoundVar::new( | 267 | TyKind::BoundVar(BoundVar::new( |
264 | ctx.in_binders, | 268 | self.in_binders, |
265 | idx as usize + parent_params + self_params + list_params, | 269 | idx as usize + parent_params + self_params + list_params, |
266 | )) | 270 | )) |
271 | .intern(&Interner) | ||
267 | } | 272 | } |
268 | ImplTraitLoweringMode::Disallowed => { | 273 | ImplTraitLoweringMode::Disallowed => { |
269 | // FIXME: report error | 274 | // FIXME: report error |
270 | Ty::Unknown | 275 | TyKind::Unknown.intern(&Interner) |
271 | } | 276 | } |
272 | } | 277 | } |
273 | } | 278 | } |
274 | TypeRef::Error => Ty::Unknown, | 279 | TypeRef::Error => TyKind::Unknown.intern(&Interner), |
275 | }; | 280 | }; |
276 | (ty, res) | 281 | (ty, res) |
277 | } | 282 | } |
@@ -279,7 +284,7 @@ impl Ty { | |||
279 | /// This is only for `generic_predicates_for_param`, where we can't just | 284 | /// This is only for `generic_predicates_for_param`, where we can't just |
280 | /// lower the self types of the predicates since that could lead to cycles. | 285 | /// lower the self types of the predicates since that could lead to cycles. |
281 | /// So we just check here if the `type_ref` resolves to a generic param, and which. | 286 | /// So we just check here if the `type_ref` resolves to a generic param, and which. |
282 | fn from_hir_only_param(ctx: &TyLoweringContext<'_>, type_ref: &TypeRef) -> Option<TypeParamId> { | 287 | fn lower_ty_only_param(&self, type_ref: &TypeRef) -> Option<TypeParamId> { |
283 | let path = match type_ref { | 288 | let path = match type_ref { |
284 | TypeRef::Path(path) => path, | 289 | TypeRef::Path(path) => path, |
285 | _ => return None, | 290 | _ => return None, |
@@ -291,7 +296,7 @@ impl Ty { | |||
291 | return None; | 296 | return None; |
292 | } | 297 | } |
293 | let resolution = | 298 | let resolution = |
294 | match ctx.resolver.resolve_path_in_type_ns(ctx.db.upcast(), path.mod_path()) { | 299 | match self.resolver.resolve_path_in_type_ns(self.db.upcast(), path.mod_path()) { |
295 | Some((it, None)) => it, | 300 | Some((it, None)) => it, |
296 | _ => return None, | 301 | _ => return None, |
297 | }; | 302 | }; |
@@ -302,8 +307,8 @@ impl Ty { | |||
302 | } | 307 | } |
303 | } | 308 | } |
304 | 309 | ||
305 | pub(crate) fn from_type_relative_path( | 310 | pub(crate) fn lower_ty_relative_path( |
306 | ctx: &TyLoweringContext<'_>, | 311 | &self, |
307 | ty: Ty, | 312 | ty: Ty, |
308 | // We need the original resolution to lower `Self::AssocTy` correctly | 313 | // We need the original resolution to lower `Self::AssocTy` correctly |
309 | res: Option<TypeNs>, | 314 | res: Option<TypeNs>, |
@@ -312,17 +317,17 @@ impl Ty { | |||
312 | if remaining_segments.len() == 1 { | 317 | if remaining_segments.len() == 1 { |
313 | // resolve unselected assoc types | 318 | // resolve unselected assoc types |
314 | let segment = remaining_segments.first().unwrap(); | 319 | let segment = remaining_segments.first().unwrap(); |
315 | (Ty::select_associated_type(ctx, res, segment), None) | 320 | (self.select_associated_type(res, segment), None) |
316 | } else if remaining_segments.len() > 1 { | 321 | } else if remaining_segments.len() > 1 { |
317 | // FIXME report error (ambiguous associated type) | 322 | // FIXME report error (ambiguous associated type) |
318 | (Ty::Unknown, None) | 323 | (TyKind::Unknown.intern(&Interner), None) |
319 | } else { | 324 | } else { |
320 | (ty, res) | 325 | (ty, res) |
321 | } | 326 | } |
322 | } | 327 | } |
323 | 328 | ||
324 | pub(crate) fn from_partly_resolved_hir_path( | 329 | pub(crate) fn lower_partly_resolved_path( |
325 | ctx: &TyLoweringContext<'_>, | 330 | &self, |
326 | resolution: TypeNs, | 331 | resolution: TypeNs, |
327 | resolved_segment: PathSegment<'_>, | 332 | resolved_segment: PathSegment<'_>, |
328 | remaining_segments: PathSegments<'_>, | 333 | remaining_segments: PathSegments<'_>, |
@@ -332,103 +337,109 @@ impl Ty { | |||
332 | TypeNs::TraitId(trait_) => { | 337 | TypeNs::TraitId(trait_) => { |
333 | // if this is a bare dyn Trait, we'll directly put the required ^0 for the self type in there | 338 | // if this is a bare dyn Trait, we'll directly put the required ^0 for the self type in there |
334 | let self_ty = if remaining_segments.len() == 0 { | 339 | let self_ty = if remaining_segments.len() == 0 { |
335 | Some(Ty::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0))) | 340 | Some( |
341 | TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0)) | ||
342 | .intern(&Interner), | ||
343 | ) | ||
336 | } else { | 344 | } else { |
337 | None | 345 | None |
338 | }; | 346 | }; |
339 | let trait_ref = | 347 | let trait_ref = |
340 | TraitRef::from_resolved_path(ctx, trait_, resolved_segment, self_ty); | 348 | self.lower_trait_ref_from_resolved_path(trait_, resolved_segment, self_ty); |
341 | let ty = if remaining_segments.len() == 1 { | 349 | let ty = if remaining_segments.len() == 1 { |
342 | let segment = remaining_segments.first().unwrap(); | 350 | let segment = remaining_segments.first().unwrap(); |
343 | let found = associated_type_by_name_including_super_traits( | 351 | let found = associated_type_by_name_including_super_traits( |
344 | ctx.db, | 352 | self.db, |
345 | trait_ref, | 353 | trait_ref, |
346 | &segment.name, | 354 | &segment.name, |
347 | ); | 355 | ); |
348 | match found { | 356 | match found { |
349 | Some((super_trait_ref, associated_ty)) => { | 357 | Some((super_trait_ref, associated_ty)) => { |
350 | // FIXME handle type parameters on the segment | 358 | // FIXME handle type parameters on the segment |
351 | Ty::Alias(AliasTy::Projection(ProjectionTy { | 359 | TyKind::Alias(AliasTy::Projection(ProjectionTy { |
352 | associated_ty, | 360 | associated_ty: to_assoc_type_id(associated_ty), |
353 | parameters: super_trait_ref.substs, | 361 | parameters: super_trait_ref.substs, |
354 | })) | 362 | })) |
363 | .intern(&Interner) | ||
355 | } | 364 | } |
356 | None => { | 365 | None => { |
357 | // FIXME: report error (associated type not found) | 366 | // FIXME: report error (associated type not found) |
358 | Ty::Unknown | 367 | TyKind::Unknown.intern(&Interner) |
359 | } | 368 | } |
360 | } | 369 | } |
361 | } else if remaining_segments.len() > 1 { | 370 | } else if remaining_segments.len() > 1 { |
362 | // FIXME report error (ambiguous associated type) | 371 | // FIXME report error (ambiguous associated type) |
363 | Ty::Unknown | 372 | TyKind::Unknown.intern(&Interner) |
364 | } else { | 373 | } else { |
365 | Ty::Dyn(Arc::new([GenericPredicate::Implemented(trait_ref)])) | 374 | TyKind::Dyn(Arc::new([GenericPredicate::Implemented(trait_ref)])) |
375 | .intern(&Interner) | ||
366 | }; | 376 | }; |
367 | return (ty, None); | 377 | return (ty, None); |
368 | } | 378 | } |
369 | TypeNs::GenericParam(param_id) => { | 379 | TypeNs::GenericParam(param_id) => { |
370 | let generics = generics( | 380 | let generics = generics( |
371 | ctx.db.upcast(), | 381 | self.db.upcast(), |
372 | ctx.resolver.generic_def().expect("generics in scope"), | 382 | self.resolver.generic_def().expect("generics in scope"), |
373 | ); | 383 | ); |
374 | match ctx.type_param_mode { | 384 | match self.type_param_mode { |
375 | TypeParamLoweringMode::Placeholder => Ty::Placeholder(param_id), | 385 | TypeParamLoweringMode::Placeholder => { |
386 | TyKind::Placeholder(to_placeholder_idx(self.db, param_id)) | ||
387 | } | ||
376 | TypeParamLoweringMode::Variable => { | 388 | TypeParamLoweringMode::Variable => { |
377 | let idx = generics.param_idx(param_id).expect("matching generics"); | 389 | let idx = generics.param_idx(param_id).expect("matching generics"); |
378 | Ty::BoundVar(BoundVar::new(ctx.in_binders, idx)) | 390 | TyKind::BoundVar(BoundVar::new(self.in_binders, idx)) |
379 | } | 391 | } |
380 | } | 392 | } |
393 | .intern(&Interner) | ||
381 | } | 394 | } |
382 | TypeNs::SelfType(impl_id) => { | 395 | TypeNs::SelfType(impl_id) => { |
383 | let generics = generics(ctx.db.upcast(), impl_id.into()); | 396 | let generics = generics(self.db.upcast(), impl_id.into()); |
384 | let substs = match ctx.type_param_mode { | 397 | let substs = match self.type_param_mode { |
385 | TypeParamLoweringMode::Placeholder => { | 398 | TypeParamLoweringMode::Placeholder => { |
386 | Substs::type_params_for_generics(&generics) | 399 | Substs::type_params_for_generics(self.db, &generics) |
387 | } | 400 | } |
388 | TypeParamLoweringMode::Variable => { | 401 | TypeParamLoweringMode::Variable => { |
389 | Substs::bound_vars(&generics, ctx.in_binders) | 402 | Substs::bound_vars(&generics, self.in_binders) |
390 | } | 403 | } |
391 | }; | 404 | }; |
392 | ctx.db.impl_self_ty(impl_id).subst(&substs) | 405 | self.db.impl_self_ty(impl_id).subst(&substs) |
393 | } | 406 | } |
394 | TypeNs::AdtSelfType(adt) => { | 407 | TypeNs::AdtSelfType(adt) => { |
395 | let generics = generics(ctx.db.upcast(), adt.into()); | 408 | let generics = generics(self.db.upcast(), adt.into()); |
396 | let substs = match ctx.type_param_mode { | 409 | let substs = match self.type_param_mode { |
397 | TypeParamLoweringMode::Placeholder => { | 410 | TypeParamLoweringMode::Placeholder => { |
398 | Substs::type_params_for_generics(&generics) | 411 | Substs::type_params_for_generics(self.db, &generics) |
399 | } | 412 | } |
400 | TypeParamLoweringMode::Variable => { | 413 | TypeParamLoweringMode::Variable => { |
401 | Substs::bound_vars(&generics, ctx.in_binders) | 414 | Substs::bound_vars(&generics, self.in_binders) |
402 | } | 415 | } |
403 | }; | 416 | }; |
404 | ctx.db.ty(adt.into()).subst(&substs) | 417 | self.db.ty(adt.into()).subst(&substs) |
405 | } | 418 | } |
406 | 419 | ||
407 | TypeNs::AdtId(it) => { | 420 | TypeNs::AdtId(it) => self.lower_path_inner(resolved_segment, it.into(), infer_args), |
408 | Ty::from_hir_path_inner(ctx, resolved_segment, it.into(), infer_args) | ||
409 | } | ||
410 | TypeNs::BuiltinType(it) => { | 421 | TypeNs::BuiltinType(it) => { |
411 | Ty::from_hir_path_inner(ctx, resolved_segment, it.into(), infer_args) | 422 | self.lower_path_inner(resolved_segment, it.into(), infer_args) |
412 | } | 423 | } |
413 | TypeNs::TypeAliasId(it) => { | 424 | TypeNs::TypeAliasId(it) => { |
414 | Ty::from_hir_path_inner(ctx, resolved_segment, it.into(), infer_args) | 425 | self.lower_path_inner(resolved_segment, it.into(), infer_args) |
415 | } | 426 | } |
416 | // FIXME: report error | 427 | // FIXME: report error |
417 | TypeNs::EnumVariantId(_) => return (Ty::Unknown, None), | 428 | TypeNs::EnumVariantId(_) => return (TyKind::Unknown.intern(&Interner), None), |
418 | }; | 429 | }; |
419 | Ty::from_type_relative_path(ctx, ty, Some(resolution), remaining_segments) | 430 | self.lower_ty_relative_path(ty, Some(resolution), remaining_segments) |
420 | } | 431 | } |
421 | 432 | ||
422 | pub(crate) fn from_hir_path(ctx: &TyLoweringContext<'_>, path: &Path) -> (Ty, Option<TypeNs>) { | 433 | pub(crate) fn lower_path(&self, path: &Path) -> (Ty, Option<TypeNs>) { |
423 | // Resolve the path (in type namespace) | 434 | // Resolve the path (in type namespace) |
424 | if let Some(type_ref) = path.type_anchor() { | 435 | if let Some(type_ref) = path.type_anchor() { |
425 | let (ty, res) = Ty::from_hir_ext(ctx, &type_ref); | 436 | let (ty, res) = self.lower_ty_ext(&type_ref); |
426 | return Ty::from_type_relative_path(ctx, ty, res, path.segments()); | 437 | return self.lower_ty_relative_path(ty, res, path.segments()); |
427 | } | 438 | } |
428 | let (resolution, remaining_index) = | 439 | let (resolution, remaining_index) = |
429 | match ctx.resolver.resolve_path_in_type_ns(ctx.db.upcast(), path.mod_path()) { | 440 | match self.resolver.resolve_path_in_type_ns(self.db.upcast(), path.mod_path()) { |
430 | Some(it) => it, | 441 | Some(it) => it, |
431 | None => return (Ty::Unknown, None), | 442 | None => return (TyKind::Unknown.intern(&Interner), None), |
432 | }; | 443 | }; |
433 | let (resolved_segment, remaining_segments) = match remaining_index { | 444 | let (resolved_segment, remaining_segments) = match remaining_index { |
434 | None => ( | 445 | None => ( |
@@ -437,31 +448,23 @@ impl Ty { | |||
437 | ), | 448 | ), |
438 | Some(i) => (path.segments().get(i - 1).unwrap(), path.segments().skip(i)), | 449 | Some(i) => (path.segments().get(i - 1).unwrap(), path.segments().skip(i)), |
439 | }; | 450 | }; |
440 | Ty::from_partly_resolved_hir_path( | 451 | self.lower_partly_resolved_path(resolution, resolved_segment, remaining_segments, false) |
441 | ctx, | ||
442 | resolution, | ||
443 | resolved_segment, | ||
444 | remaining_segments, | ||
445 | false, | ||
446 | ) | ||
447 | } | 452 | } |
448 | 453 | ||
449 | fn select_associated_type( | 454 | fn select_associated_type(&self, res: Option<TypeNs>, segment: PathSegment<'_>) -> Ty { |
450 | ctx: &TyLoweringContext<'_>, | ||
451 | res: Option<TypeNs>, | ||
452 | segment: PathSegment<'_>, | ||
453 | ) -> Ty { | ||
454 | if let Some(res) = res { | 455 | if let Some(res) = res { |
455 | let ty = | 456 | let ty = associated_type_shorthand_candidates( |
456 | associated_type_shorthand_candidates(ctx.db, res, move |name, t, associated_ty| { | 457 | self.db, |
458 | res, | ||
459 | move |name, t, associated_ty| { | ||
457 | if name == segment.name { | 460 | if name == segment.name { |
458 | let substs = match ctx.type_param_mode { | 461 | let substs = match self.type_param_mode { |
459 | TypeParamLoweringMode::Placeholder => { | 462 | TypeParamLoweringMode::Placeholder => { |
460 | // if we're lowering to placeholders, we have to put | 463 | // if we're lowering to placeholders, we have to put |
461 | // them in now | 464 | // them in now |
462 | let s = Substs::type_params( | 465 | let s = Substs::type_params( |
463 | ctx.db, | 466 | self.db, |
464 | ctx.resolver.generic_def().expect( | 467 | self.resolver.generic_def().expect( |
465 | "there should be generics if there's a generic param", | 468 | "there should be generics if there's a generic param", |
466 | ), | 469 | ), |
467 | ); | 470 | ); |
@@ -471,25 +474,29 @@ impl Ty { | |||
471 | }; | 474 | }; |
472 | // We need to shift in the bound vars, since | 475 | // We need to shift in the bound vars, since |
473 | // associated_type_shorthand_candidates does not do that | 476 | // associated_type_shorthand_candidates does not do that |
474 | let substs = substs.shift_bound_vars(ctx.in_binders); | 477 | let substs = substs.shift_bound_vars(self.in_binders); |
475 | // FIXME handle type parameters on the segment | 478 | // FIXME handle type parameters on the segment |
476 | return Some(Ty::Alias(AliasTy::Projection(ProjectionTy { | 479 | return Some( |
477 | associated_ty, | 480 | TyKind::Alias(AliasTy::Projection(ProjectionTy { |
478 | parameters: substs, | 481 | associated_ty: to_assoc_type_id(associated_ty), |
479 | }))); | 482 | parameters: substs, |
483 | })) | ||
484 | .intern(&Interner), | ||
485 | ); | ||
480 | } | 486 | } |
481 | 487 | ||
482 | None | 488 | None |
483 | }); | 489 | }, |
490 | ); | ||
484 | 491 | ||
485 | ty.unwrap_or(Ty::Unknown) | 492 | ty.unwrap_or(TyKind::Unknown.intern(&Interner)) |
486 | } else { | 493 | } else { |
487 | Ty::Unknown | 494 | TyKind::Unknown.intern(&Interner) |
488 | } | 495 | } |
489 | } | 496 | } |
490 | 497 | ||
491 | fn from_hir_path_inner( | 498 | fn lower_path_inner( |
492 | ctx: &TyLoweringContext<'_>, | 499 | &self, |
493 | segment: PathSegment<'_>, | 500 | segment: PathSegment<'_>, |
494 | typeable: TyDefId, | 501 | typeable: TyDefId, |
495 | infer_args: bool, | 502 | infer_args: bool, |
@@ -499,14 +506,14 @@ impl Ty { | |||
499 | TyDefId::AdtId(it) => Some(it.into()), | 506 | TyDefId::AdtId(it) => Some(it.into()), |
500 | TyDefId::TypeAliasId(it) => Some(it.into()), | 507 | TyDefId::TypeAliasId(it) => Some(it.into()), |
501 | }; | 508 | }; |
502 | let substs = substs_from_path_segment(ctx, segment, generic_def, infer_args); | 509 | let substs = self.substs_from_path_segment(segment, generic_def, infer_args); |
503 | ctx.db.ty(typeable).subst(&substs) | 510 | self.db.ty(typeable).subst(&substs) |
504 | } | 511 | } |
505 | 512 | ||
506 | /// Collect generic arguments from a path into a `Substs`. See also | 513 | /// Collect generic arguments from a path into a `Substs`. See also |
507 | /// `create_substs_for_ast_path` and `def_to_ty` in rustc. | 514 | /// `create_substs_for_ast_path` and `def_to_ty` in rustc. |
508 | pub(super) fn substs_from_path( | 515 | pub(super) fn substs_from_path( |
509 | ctx: &TyLoweringContext<'_>, | 516 | &self, |
510 | path: &Path, | 517 | path: &Path, |
511 | // Note that we don't call `db.value_type(resolved)` here, | 518 | // Note that we don't call `db.value_type(resolved)` here, |
512 | // `ValueTyDefId` is just a convenient way to pass generics and | 519 | // `ValueTyDefId` is just a convenient way to pass generics and |
@@ -536,169 +543,161 @@ impl Ty { | |||
536 | (segment, Some(var.parent.into())) | 543 | (segment, Some(var.parent.into())) |
537 | } | 544 | } |
538 | }; | 545 | }; |
539 | substs_from_path_segment(ctx, segment, generic_def, infer_args) | 546 | self.substs_from_path_segment(segment, generic_def, infer_args) |
540 | } | 547 | } |
541 | } | ||
542 | 548 | ||
543 | fn substs_from_path_segment( | 549 | fn substs_from_path_segment( |
544 | ctx: &TyLoweringContext<'_>, | 550 | &self, |
545 | segment: PathSegment<'_>, | 551 | segment: PathSegment<'_>, |
546 | def_generic: Option<GenericDefId>, | 552 | def_generic: Option<GenericDefId>, |
547 | infer_args: bool, | 553 | infer_args: bool, |
548 | ) -> Substs { | 554 | ) -> Substs { |
549 | let mut substs = Vec::new(); | 555 | let mut substs = Vec::new(); |
550 | let def_generics = def_generic.map(|def| generics(ctx.db.upcast(), def)); | 556 | let def_generics = def_generic.map(|def| generics(self.db.upcast(), def)); |
551 | 557 | ||
552 | let (parent_params, self_params, type_params, impl_trait_params) = | 558 | let (parent_params, self_params, type_params, impl_trait_params) = |
553 | def_generics.map_or((0, 0, 0, 0), |g| g.provenance_split()); | 559 | def_generics.map_or((0, 0, 0, 0), |g| g.provenance_split()); |
554 | let total_len = parent_params + self_params + type_params + impl_trait_params; | 560 | let total_len = parent_params + self_params + type_params + impl_trait_params; |
555 | 561 | ||
556 | substs.extend(iter::repeat(Ty::Unknown).take(parent_params)); | 562 | substs.extend(iter::repeat(TyKind::Unknown.intern(&Interner)).take(parent_params)); |
557 | 563 | ||
558 | let mut had_explicit_type_args = false; | 564 | let mut had_explicit_type_args = false; |
559 | 565 | ||
560 | if let Some(generic_args) = &segment.args_and_bindings { | 566 | if let Some(generic_args) = &segment.args_and_bindings { |
561 | if !generic_args.has_self_type { | 567 | if !generic_args.has_self_type { |
562 | substs.extend(iter::repeat(Ty::Unknown).take(self_params)); | 568 | substs.extend(iter::repeat(TyKind::Unknown.intern(&Interner)).take(self_params)); |
563 | } | 569 | } |
564 | let expected_num = | 570 | let expected_num = |
565 | if generic_args.has_self_type { self_params + type_params } else { type_params }; | 571 | if generic_args.has_self_type { self_params + type_params } else { type_params }; |
566 | let skip = if generic_args.has_self_type && self_params == 0 { 1 } else { 0 }; | 572 | let skip = if generic_args.has_self_type && self_params == 0 { 1 } else { 0 }; |
567 | // if args are provided, it should be all of them, but we can't rely on that | 573 | // if args are provided, it should be all of them, but we can't rely on that |
568 | for arg in generic_args | 574 | for arg in generic_args |
569 | .args | 575 | .args |
570 | .iter() | 576 | .iter() |
571 | .filter(|arg| matches!(arg, GenericArg::Type(_))) | 577 | .filter(|arg| matches!(arg, GenericArg::Type(_))) |
572 | .skip(skip) | 578 | .skip(skip) |
573 | .take(expected_num) | 579 | .take(expected_num) |
574 | { | 580 | { |
575 | match arg { | 581 | match arg { |
576 | GenericArg::Type(type_ref) => { | 582 | GenericArg::Type(type_ref) => { |
577 | had_explicit_type_args = true; | 583 | had_explicit_type_args = true; |
578 | let ty = Ty::from_hir(ctx, type_ref); | 584 | let ty = self.lower_ty(type_ref); |
579 | substs.push(ty); | 585 | substs.push(ty); |
586 | } | ||
587 | GenericArg::Lifetime(_) => {} | ||
580 | } | 588 | } |
581 | GenericArg::Lifetime(_) => {} | ||
582 | } | 589 | } |
583 | } | 590 | } |
584 | } | ||
585 | 591 | ||
586 | // handle defaults. In expression or pattern path segments without | 592 | // handle defaults. In expression or pattern path segments without |
587 | // explicitly specified type arguments, missing type arguments are inferred | 593 | // explicitly specified type arguments, missing type arguments are inferred |
588 | // (i.e. defaults aren't used). | 594 | // (i.e. defaults aren't used). |
589 | if !infer_args || had_explicit_type_args { | 595 | if !infer_args || had_explicit_type_args { |
590 | if let Some(def_generic) = def_generic { | 596 | if let Some(def_generic) = def_generic { |
591 | let defaults = ctx.db.generic_defaults(def_generic); | 597 | let defaults = self.db.generic_defaults(def_generic); |
592 | assert_eq!(total_len, defaults.len()); | 598 | assert_eq!(total_len, defaults.len()); |
593 | 599 | ||
594 | for default_ty in defaults.iter().skip(substs.len()) { | 600 | for default_ty in defaults.iter().skip(substs.len()) { |
595 | // each default can depend on the previous parameters | 601 | // each default can depend on the previous parameters |
596 | let substs_so_far = Substs(substs.clone().into()); | 602 | let substs_so_far = Substs(substs.clone().into()); |
597 | substs.push(default_ty.clone().subst(&substs_so_far)); | 603 | substs.push(default_ty.clone().subst(&substs_so_far)); |
604 | } | ||
598 | } | 605 | } |
599 | } | 606 | } |
600 | } | ||
601 | 607 | ||
602 | // add placeholders for args that were not provided | 608 | // add placeholders for args that were not provided |
603 | // FIXME: emit diagnostics in contexts where this is not allowed | 609 | // FIXME: emit diagnostics in contexts where this is not allowed |
604 | for _ in substs.len()..total_len { | 610 | for _ in substs.len()..total_len { |
605 | substs.push(Ty::Unknown); | 611 | substs.push(TyKind::Unknown.intern(&Interner)); |
606 | } | 612 | } |
607 | assert_eq!(substs.len(), total_len); | 613 | assert_eq!(substs.len(), total_len); |
608 | 614 | ||
609 | Substs(substs.into()) | 615 | Substs(substs.into()) |
610 | } | 616 | } |
611 | 617 | ||
612 | impl TraitRef { | 618 | fn lower_trait_ref_from_path( |
613 | fn from_path( | 619 | &self, |
614 | ctx: &TyLoweringContext<'_>, | ||
615 | path: &Path, | 620 | path: &Path, |
616 | explicit_self_ty: Option<Ty>, | 621 | explicit_self_ty: Option<Ty>, |
617 | ) -> Option<Self> { | 622 | ) -> Option<TraitRef> { |
618 | let resolved = | 623 | let resolved = |
619 | match ctx.resolver.resolve_path_in_type_ns_fully(ctx.db.upcast(), path.mod_path())? { | 624 | match self.resolver.resolve_path_in_type_ns_fully(self.db.upcast(), path.mod_path())? { |
620 | TypeNs::TraitId(tr) => tr, | 625 | TypeNs::TraitId(tr) => tr, |
621 | _ => return None, | 626 | _ => return None, |
622 | }; | 627 | }; |
623 | let segment = path.segments().last().expect("path should have at least one segment"); | 628 | let segment = path.segments().last().expect("path should have at least one segment"); |
624 | Some(TraitRef::from_resolved_path(ctx, resolved, segment, explicit_self_ty)) | 629 | Some(self.lower_trait_ref_from_resolved_path(resolved, segment, explicit_self_ty)) |
625 | } | 630 | } |
626 | 631 | ||
627 | pub(crate) fn from_resolved_path( | 632 | pub(crate) fn lower_trait_ref_from_resolved_path( |
628 | ctx: &TyLoweringContext<'_>, | 633 | &self, |
629 | resolved: TraitId, | 634 | resolved: TraitId, |
630 | segment: PathSegment<'_>, | 635 | segment: PathSegment<'_>, |
631 | explicit_self_ty: Option<Ty>, | 636 | explicit_self_ty: Option<Ty>, |
632 | ) -> Self { | 637 | ) -> TraitRef { |
633 | let mut substs = TraitRef::substs_from_path(ctx, segment, resolved); | 638 | let mut substs = self.trait_ref_substs_from_path(segment, resolved); |
634 | if let Some(self_ty) = explicit_self_ty { | 639 | if let Some(self_ty) = explicit_self_ty { |
635 | make_mut_slice(&mut substs.0)[0] = self_ty; | 640 | make_mut_slice(&mut substs.0)[0] = self_ty; |
636 | } | 641 | } |
637 | TraitRef { trait_: resolved, substs } | 642 | TraitRef { trait_: resolved, substs } |
638 | } | 643 | } |
639 | 644 | ||
640 | fn from_hir( | 645 | fn lower_trait_ref( |
641 | ctx: &TyLoweringContext<'_>, | 646 | &self, |
642 | type_ref: &TypeRef, | 647 | type_ref: &TypeRef, |
643 | explicit_self_ty: Option<Ty>, | 648 | explicit_self_ty: Option<Ty>, |
644 | ) -> Option<Self> { | 649 | ) -> Option<TraitRef> { |
645 | let path = match type_ref { | 650 | let path = match type_ref { |
646 | TypeRef::Path(path) => path, | 651 | TypeRef::Path(path) => path, |
647 | _ => return None, | 652 | _ => return None, |
648 | }; | 653 | }; |
649 | TraitRef::from_path(ctx, path, explicit_self_ty) | 654 | self.lower_trait_ref_from_path(path, explicit_self_ty) |
650 | } | 655 | } |
651 | 656 | ||
652 | fn substs_from_path( | 657 | fn trait_ref_substs_from_path(&self, segment: PathSegment<'_>, resolved: TraitId) -> Substs { |
653 | ctx: &TyLoweringContext<'_>, | 658 | self.substs_from_path_segment(segment, Some(resolved.into()), false) |
654 | segment: PathSegment<'_>, | ||
655 | resolved: TraitId, | ||
656 | ) -> Substs { | ||
657 | substs_from_path_segment(ctx, segment, Some(resolved.into()), false) | ||
658 | } | 659 | } |
659 | } | ||
660 | 660 | ||
661 | impl GenericPredicate { | 661 | pub(crate) fn lower_where_predicate( |
662 | pub(crate) fn from_where_predicate<'a>( | 662 | &'a self, |
663 | ctx: &'a TyLoweringContext<'a>, | ||
664 | where_predicate: &'a WherePredicate, | 663 | where_predicate: &'a WherePredicate, |
665 | ) -> impl Iterator<Item = GenericPredicate> + 'a { | 664 | ) -> impl Iterator<Item = GenericPredicate> + 'a { |
666 | match where_predicate { | 665 | match where_predicate { |
667 | WherePredicate::ForLifetime { target, bound, .. } | 666 | WherePredicate::ForLifetime { target, bound, .. } |
668 | | WherePredicate::TypeBound { target, bound } => { | 667 | | WherePredicate::TypeBound { target, bound } => { |
669 | let self_ty = match target { | 668 | let self_ty = match target { |
670 | WherePredicateTypeTarget::TypeRef(type_ref) => Ty::from_hir(ctx, type_ref), | 669 | WherePredicateTypeTarget::TypeRef(type_ref) => self.lower_ty(type_ref), |
671 | WherePredicateTypeTarget::TypeParam(param_id) => { | 670 | WherePredicateTypeTarget::TypeParam(param_id) => { |
672 | let generic_def = ctx.resolver.generic_def().expect("generics in scope"); | 671 | let generic_def = self.resolver.generic_def().expect("generics in scope"); |
673 | let generics = generics(ctx.db.upcast(), generic_def); | 672 | let generics = generics(self.db.upcast(), generic_def); |
674 | let param_id = | 673 | let param_id = |
675 | hir_def::TypeParamId { parent: generic_def, local_id: *param_id }; | 674 | hir_def::TypeParamId { parent: generic_def, local_id: *param_id }; |
676 | match ctx.type_param_mode { | 675 | let placeholder = to_placeholder_idx(self.db, param_id); |
677 | TypeParamLoweringMode::Placeholder => Ty::Placeholder(param_id), | 676 | match self.type_param_mode { |
677 | TypeParamLoweringMode::Placeholder => TyKind::Placeholder(placeholder), | ||
678 | TypeParamLoweringMode::Variable => { | 678 | TypeParamLoweringMode::Variable => { |
679 | let idx = generics.param_idx(param_id).expect("matching generics"); | 679 | let idx = generics.param_idx(param_id).expect("matching generics"); |
680 | Ty::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, idx)) | 680 | TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, idx)) |
681 | } | 681 | } |
682 | } | 682 | } |
683 | .intern(&Interner) | ||
683 | } | 684 | } |
684 | }; | 685 | }; |
685 | GenericPredicate::from_type_bound(ctx, bound, self_ty) | 686 | self.lower_type_bound(bound, self_ty).collect::<Vec<_>>().into_iter() |
686 | .collect::<Vec<_>>() | ||
687 | .into_iter() | ||
688 | } | 687 | } |
689 | WherePredicate::Lifetime { .. } => vec![].into_iter(), | 688 | WherePredicate::Lifetime { .. } => vec![].into_iter(), |
690 | } | 689 | } |
691 | } | 690 | } |
692 | 691 | ||
693 | pub(crate) fn from_type_bound<'a>( | 692 | pub(crate) fn lower_type_bound( |
694 | ctx: &'a TyLoweringContext<'a>, | 693 | &'a self, |
695 | bound: &'a TypeBound, | 694 | bound: &'a TypeBound, |
696 | self_ty: Ty, | 695 | self_ty: Ty, |
697 | ) -> impl Iterator<Item = GenericPredicate> + 'a { | 696 | ) -> impl Iterator<Item = GenericPredicate> + 'a { |
698 | let mut bindings = None; | 697 | let mut bindings = None; |
699 | let trait_ref = match bound { | 698 | let trait_ref = match bound { |
700 | TypeBound::Path(path) => { | 699 | TypeBound::Path(path) => { |
701 | bindings = TraitRef::from_path(ctx, path, Some(self_ty)); | 700 | bindings = self.lower_trait_ref_from_path(path, Some(self_ty)); |
702 | Some( | 701 | Some( |
703 | bindings.clone().map_or(GenericPredicate::Error, GenericPredicate::Implemented), | 702 | bindings.clone().map_or(GenericPredicate::Error, GenericPredicate::Implemented), |
704 | ) | 703 | ) |
@@ -709,64 +708,62 @@ impl GenericPredicate { | |||
709 | trait_ref.into_iter().chain( | 708 | trait_ref.into_iter().chain( |
710 | bindings | 709 | bindings |
711 | .into_iter() | 710 | .into_iter() |
712 | .flat_map(move |tr| assoc_type_bindings_from_type_bound(ctx, bound, tr)), | 711 | .flat_map(move |tr| self.assoc_type_bindings_from_type_bound(bound, tr)), |
713 | ) | 712 | ) |
714 | } | 713 | } |
715 | } | ||
716 | 714 | ||
717 | fn assoc_type_bindings_from_type_bound<'a>( | 715 | fn assoc_type_bindings_from_type_bound( |
718 | ctx: &'a TyLoweringContext<'a>, | 716 | &'a self, |
719 | bound: &'a TypeBound, | 717 | bound: &'a TypeBound, |
720 | trait_ref: TraitRef, | 718 | trait_ref: TraitRef, |
721 | ) -> impl Iterator<Item = GenericPredicate> + 'a { | 719 | ) -> impl Iterator<Item = GenericPredicate> + 'a { |
722 | let last_segment = match bound { | 720 | let last_segment = match bound { |
723 | TypeBound::Path(path) => path.segments().last(), | 721 | TypeBound::Path(path) => path.segments().last(), |
724 | TypeBound::Error | TypeBound::Lifetime(_) => None, | 722 | TypeBound::Error | TypeBound::Lifetime(_) => None, |
725 | }; | 723 | }; |
726 | last_segment | 724 | last_segment |
727 | .into_iter() | 725 | .into_iter() |
728 | .flat_map(|segment| segment.args_and_bindings.into_iter()) | 726 | .flat_map(|segment| segment.args_and_bindings.into_iter()) |
729 | .flat_map(|args_and_bindings| args_and_bindings.bindings.iter()) | 727 | .flat_map(|args_and_bindings| args_and_bindings.bindings.iter()) |
730 | .flat_map(move |binding| { | 728 | .flat_map(move |binding| { |
731 | let found = associated_type_by_name_including_super_traits( | 729 | let found = associated_type_by_name_including_super_traits( |
732 | ctx.db, | 730 | self.db, |
733 | trait_ref.clone(), | 731 | trait_ref.clone(), |
734 | &binding.name, | 732 | &binding.name, |
735 | ); | 733 | ); |
736 | let (super_trait_ref, associated_ty) = match found { | 734 | let (super_trait_ref, associated_ty) = match found { |
737 | None => return SmallVec::<[GenericPredicate; 1]>::new(), | 735 | None => return SmallVec::<[GenericPredicate; 1]>::new(), |
738 | Some(t) => t, | 736 | Some(t) => t, |
739 | }; | 737 | }; |
740 | let projection_ty = ProjectionTy { associated_ty, parameters: super_trait_ref.substs }; | 738 | let projection_ty = ProjectionTy { |
741 | let mut preds = SmallVec::with_capacity( | 739 | associated_ty: to_assoc_type_id(associated_ty), |
742 | binding.type_ref.as_ref().map_or(0, |_| 1) + binding.bounds.len(), | 740 | parameters: super_trait_ref.substs, |
743 | ); | 741 | }; |
744 | if let Some(type_ref) = &binding.type_ref { | 742 | let mut preds = SmallVec::with_capacity( |
745 | let ty = Ty::from_hir(ctx, type_ref); | 743 | binding.type_ref.as_ref().map_or(0, |_| 1) + binding.bounds.len(), |
746 | let projection_predicate = | 744 | ); |
747 | ProjectionPredicate { projection_ty: projection_ty.clone(), ty }; | 745 | if let Some(type_ref) = &binding.type_ref { |
748 | preds.push(GenericPredicate::Projection(projection_predicate)); | 746 | let ty = self.lower_ty(type_ref); |
749 | } | 747 | let projection_predicate = |
750 | for bound in &binding.bounds { | 748 | ProjectionPredicate { projection_ty: projection_ty.clone(), ty }; |
751 | preds.extend(GenericPredicate::from_type_bound( | 749 | preds.push(GenericPredicate::Projection(projection_predicate)); |
752 | ctx, | 750 | } |
753 | bound, | 751 | for bound in &binding.bounds { |
754 | Ty::Alias(AliasTy::Projection(projection_ty.clone())), | 752 | preds.extend(self.lower_type_bound( |
755 | )); | 753 | bound, |
756 | } | 754 | TyKind::Alias(AliasTy::Projection(projection_ty.clone())).intern(&Interner), |
757 | preds | 755 | )); |
758 | }) | 756 | } |
759 | } | 757 | preds |
758 | }) | ||
759 | } | ||
760 | 760 | ||
761 | impl ReturnTypeImplTrait { | 761 | fn lower_impl_trait(&self, bounds: &[TypeBound]) -> ReturnTypeImplTrait { |
762 | fn from_hir(ctx: &TyLoweringContext, bounds: &[TypeBound]) -> Self { | ||
763 | cov_mark::hit!(lower_rpit); | 762 | cov_mark::hit!(lower_rpit); |
764 | let self_ty = Ty::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0)); | 763 | let self_ty = |
765 | let predicates = ctx.with_shifted_in(DebruijnIndex::ONE, |ctx| { | 764 | TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0)).intern(&Interner); |
766 | bounds | 765 | let predicates = self.with_shifted_in(DebruijnIndex::ONE, |ctx| { |
767 | .iter() | 766 | bounds.iter().flat_map(|b| ctx.lower_type_bound(b, self_ty.clone())).collect() |
768 | .flat_map(|b| GenericPredicate::from_type_bound(ctx, b, self_ty.clone())) | ||
769 | .collect() | ||
770 | }); | 767 | }); |
771 | ReturnTypeImplTrait { bounds: Binders::new(1, predicates) } | 768 | ReturnTypeImplTrait { bounds: Binders::new(1, predicates) } |
772 | } | 769 | } |
@@ -862,7 +859,7 @@ pub(crate) fn field_types_query( | |||
862 | let ctx = | 859 | let ctx = |
863 | TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable); | 860 | TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable); |
864 | for (field_id, field_data) in var_data.fields().iter() { | 861 | for (field_id, field_data) in var_data.fields().iter() { |
865 | res.insert(field_id, Binders::new(generics.len(), Ty::from_hir(&ctx, &field_data.type_ref))) | 862 | res.insert(field_id, Binders::new(generics.len(), ctx.lower_ty(&field_data.type_ref))) |
866 | } | 863 | } |
867 | Arc::new(res) | 864 | Arc::new(res) |
868 | } | 865 | } |
@@ -890,16 +887,13 @@ pub(crate) fn generic_predicates_for_param_query( | |||
890 | WherePredicate::ForLifetime { target, .. } | 887 | WherePredicate::ForLifetime { target, .. } |
891 | | WherePredicate::TypeBound { target, .. } => match target { | 888 | | WherePredicate::TypeBound { target, .. } => match target { |
892 | WherePredicateTypeTarget::TypeRef(type_ref) => { | 889 | WherePredicateTypeTarget::TypeRef(type_ref) => { |
893 | Ty::from_hir_only_param(&ctx, type_ref) == Some(param_id) | 890 | ctx.lower_ty_only_param(type_ref) == Some(param_id) |
894 | } | 891 | } |
895 | WherePredicateTypeTarget::TypeParam(local_id) => *local_id == param_id.local_id, | 892 | WherePredicateTypeTarget::TypeParam(local_id) => *local_id == param_id.local_id, |
896 | }, | 893 | }, |
897 | WherePredicate::Lifetime { .. } => false, | 894 | WherePredicate::Lifetime { .. } => false, |
898 | }) | 895 | }) |
899 | .flat_map(|pred| { | 896 | .flat_map(|pred| ctx.lower_where_predicate(pred).map(|p| Binders::new(generics.len(), p))) |
900 | GenericPredicate::from_where_predicate(&ctx, pred) | ||
901 | .map(|p| Binders::new(generics.len(), p)) | ||
902 | }) | ||
903 | .collect() | 897 | .collect() |
904 | } | 898 | } |
905 | 899 | ||
@@ -911,55 +905,55 @@ pub(crate) fn generic_predicates_for_param_recover( | |||
911 | Arc::new([]) | 905 | Arc::new([]) |
912 | } | 906 | } |
913 | 907 | ||
914 | impl TraitEnvironment { | 908 | pub(crate) fn trait_environment_query( |
915 | pub fn lower(db: &dyn HirDatabase, resolver: &Resolver) -> Arc<TraitEnvironment> { | 909 | db: &dyn HirDatabase, |
916 | let ctx = TyLoweringContext::new(db, &resolver) | 910 | def: GenericDefId, |
917 | .with_type_param_mode(TypeParamLoweringMode::Placeholder); | 911 | ) -> Arc<TraitEnvironment> { |
918 | let mut traits_in_scope = Vec::new(); | 912 | let resolver = def.resolver(db.upcast()); |
919 | let mut clauses = Vec::new(); | 913 | let ctx = TyLoweringContext::new(db, &resolver) |
920 | for pred in resolver.where_predicates_in_scope() { | 914 | .with_type_param_mode(TypeParamLoweringMode::Placeholder); |
921 | for pred in GenericPredicate::from_where_predicate(&ctx, pred) { | 915 | let mut traits_in_scope = Vec::new(); |
922 | if pred.is_error() { | 916 | let mut clauses = Vec::new(); |
923 | continue; | 917 | for pred in resolver.where_predicates_in_scope() { |
924 | } | 918 | for pred in ctx.lower_where_predicate(pred) { |
925 | if let GenericPredicate::Implemented(tr) = &pred { | 919 | if pred.is_error() { |
926 | traits_in_scope.push((tr.self_ty().clone(), tr.trait_)); | 920 | continue; |
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)); | ||
931 | } | 921 | } |
932 | } | 922 | if let GenericPredicate::Implemented(tr) = &pred { |
933 | 923 | traits_in_scope.push((tr.self_ty().clone(), tr.trait_)); | |
934 | if let Some(def) = resolver.generic_def() { | ||
935 | let container: Option<AssocContainerId> = match def { | ||
936 | // FIXME: is there a function for this? | ||
937 | GenericDefId::FunctionId(f) => Some(f.lookup(db.upcast()).container), | ||
938 | GenericDefId::AdtId(_) => None, | ||
939 | GenericDefId::TraitId(_) => None, | ||
940 | GenericDefId::TypeAliasId(t) => Some(t.lookup(db.upcast()).container), | ||
941 | GenericDefId::ImplId(_) => None, | ||
942 | GenericDefId::EnumVariantId(_) => None, | ||
943 | GenericDefId::ConstId(c) => Some(c.lookup(db.upcast()).container), | ||
944 | }; | ||
945 | if let Some(AssocContainerId::TraitId(trait_id)) = container { | ||
946 | // add `Self: Trait<T1, T2, ...>` to the environment in trait | ||
947 | // function default implementations (and hypothetical code | ||
948 | // inside consts or type aliases) | ||
949 | cov_mark::hit!(trait_self_implements_self); | ||
950 | let substs = Substs::type_params(db, trait_id); | ||
951 | let trait_ref = TraitRef { trait_: trait_id, substs }; | ||
952 | let pred = GenericPredicate::Implemented(trait_ref); | ||
953 | let program_clause: chalk_ir::ProgramClause<Interner> = | ||
954 | pred.clone().to_chalk(db).cast(&Interner); | ||
955 | clauses.push(program_clause.into_from_env_clause(&Interner)); | ||
956 | } | 924 | } |
925 | let program_clause: chalk_ir::ProgramClause<Interner> = | ||
926 | pred.clone().to_chalk(db).cast(&Interner); | ||
927 | clauses.push(program_clause.into_from_env_clause(&Interner)); | ||
957 | } | 928 | } |
929 | } | ||
958 | 930 | ||
959 | let env = chalk_ir::Environment::new(&Interner).add_clauses(&Interner, clauses); | 931 | let container: Option<AssocContainerId> = match def { |
960 | 932 | // FIXME: is there a function for this? | |
961 | Arc::new(TraitEnvironment { traits_from_clauses: traits_in_scope, env }) | 933 | GenericDefId::FunctionId(f) => Some(f.lookup(db.upcast()).container), |
934 | GenericDefId::AdtId(_) => None, | ||
935 | GenericDefId::TraitId(_) => None, | ||
936 | GenericDefId::TypeAliasId(t) => Some(t.lookup(db.upcast()).container), | ||
937 | GenericDefId::ImplId(_) => None, | ||
938 | GenericDefId::EnumVariantId(_) => None, | ||
939 | GenericDefId::ConstId(c) => Some(c.lookup(db.upcast()).container), | ||
940 | }; | ||
941 | if let Some(AssocContainerId::TraitId(trait_id)) = container { | ||
942 | // add `Self: Trait<T1, T2, ...>` to the environment in trait | ||
943 | // function default implementations (and hypothetical code | ||
944 | // inside consts or type aliases) | ||
945 | cov_mark::hit!(trait_self_implements_self); | ||
946 | let substs = Substs::type_params(db, trait_id); | ||
947 | let trait_ref = TraitRef { trait_: trait_id, substs }; | ||
948 | let pred = GenericPredicate::Implemented(trait_ref); | ||
949 | let program_clause: chalk_ir::ProgramClause<Interner> = | ||
950 | pred.clone().to_chalk(db).cast(&Interner); | ||
951 | clauses.push(program_clause.into_from_env_clause(&Interner)); | ||
962 | } | 952 | } |
953 | |||
954 | let env = chalk_ir::Environment::new(&Interner).add_clauses(&Interner, clauses); | ||
955 | |||
956 | Arc::new(TraitEnvironment { traits_from_clauses: traits_in_scope, env }) | ||
963 | } | 957 | } |
964 | 958 | ||
965 | /// Resolve the where clause(s) of an item with generics. | 959 | /// Resolve the where clause(s) of an item with generics. |
@@ -973,10 +967,7 @@ pub(crate) fn generic_predicates_query( | |||
973 | let generics = generics(db.upcast(), def); | 967 | let generics = generics(db.upcast(), def); |
974 | resolver | 968 | resolver |
975 | .where_predicates_in_scope() | 969 | .where_predicates_in_scope() |
976 | .flat_map(|pred| { | 970 | .flat_map(|pred| ctx.lower_where_predicate(pred).map(|p| Binders::new(generics.len(), p))) |
977 | GenericPredicate::from_where_predicate(&ctx, pred) | ||
978 | .map(|p| Binders::new(generics.len(), p)) | ||
979 | }) | ||
980 | .collect() | 971 | .collect() |
981 | } | 972 | } |
982 | 973 | ||
@@ -994,17 +985,18 @@ pub(crate) fn generic_defaults_query( | |||
994 | .iter() | 985 | .iter() |
995 | .enumerate() | 986 | .enumerate() |
996 | .map(|(idx, (_, p))| { | 987 | .map(|(idx, (_, p))| { |
997 | let mut ty = p.default.as_ref().map_or(Ty::Unknown, |t| Ty::from_hir(&ctx, t)); | 988 | let mut ty = |
989 | p.default.as_ref().map_or(TyKind::Unknown.intern(&Interner), |t| ctx.lower_ty(t)); | ||
998 | 990 | ||
999 | // Each default can only refer to previous parameters. | 991 | // Each default can only refer to previous parameters. |
1000 | ty.walk_mut_binders( | 992 | ty.walk_mut_binders( |
1001 | &mut |ty, binders| match ty { | 993 | &mut |ty, binders| match &mut ty.0 { |
1002 | Ty::BoundVar(BoundVar { debruijn, index }) if *debruijn == binders => { | 994 | TyKind::BoundVar(BoundVar { debruijn, index }) if *debruijn == binders => { |
1003 | if *index >= idx { | 995 | if *index >= idx { |
1004 | // type variable default referring to parameter coming | 996 | // type variable default referring to parameter coming |
1005 | // after it. This is forbidden (FIXME: report | 997 | // after it. This is forbidden (FIXME: report |
1006 | // diagnostic) | 998 | // diagnostic) |
1007 | *ty = Ty::Unknown; | 999 | *ty = TyKind::Unknown.intern(&Interner); |
1008 | } | 1000 | } |
1009 | } | 1001 | } |
1010 | _ => {} | 1002 | _ => {} |
@@ -1025,11 +1017,11 @@ fn fn_sig_for_fn(db: &dyn HirDatabase, def: FunctionId) -> PolyFnSig { | |||
1025 | let ctx_params = TyLoweringContext::new(db, &resolver) | 1017 | let ctx_params = TyLoweringContext::new(db, &resolver) |
1026 | .with_impl_trait_mode(ImplTraitLoweringMode::Variable) | 1018 | .with_impl_trait_mode(ImplTraitLoweringMode::Variable) |
1027 | .with_type_param_mode(TypeParamLoweringMode::Variable); | 1019 | .with_type_param_mode(TypeParamLoweringMode::Variable); |
1028 | let params = data.params.iter().map(|tr| Ty::from_hir(&ctx_params, tr)).collect::<Vec<_>>(); | 1020 | let params = data.params.iter().map(|tr| (&ctx_params).lower_ty(tr)).collect::<Vec<_>>(); |
1029 | let ctx_ret = TyLoweringContext::new(db, &resolver) | 1021 | let ctx_ret = TyLoweringContext::new(db, &resolver) |
1030 | .with_impl_trait_mode(ImplTraitLoweringMode::Opaque) | 1022 | .with_impl_trait_mode(ImplTraitLoweringMode::Opaque) |
1031 | .with_type_param_mode(TypeParamLoweringMode::Variable); | 1023 | .with_type_param_mode(TypeParamLoweringMode::Variable); |
1032 | let ret = Ty::from_hir(&ctx_ret, &data.ret_type); | 1024 | let ret = (&ctx_ret).lower_ty(&data.ret_type); |
1033 | let generics = generics(db.upcast(), def.into()); | 1025 | let generics = generics(db.upcast(), def.into()); |
1034 | let num_binders = generics.len(); | 1026 | let num_binders = generics.len(); |
1035 | Binders::new(num_binders, CallableSig::from_params_and_return(params, ret, data.is_varargs)) | 1027 | Binders::new(num_binders, CallableSig::from_params_and_return(params, ret, data.is_varargs)) |
@@ -1040,7 +1032,10 @@ fn fn_sig_for_fn(db: &dyn HirDatabase, def: FunctionId) -> PolyFnSig { | |||
1040 | fn type_for_fn(db: &dyn HirDatabase, def: FunctionId) -> Binders<Ty> { | 1032 | fn type_for_fn(db: &dyn HirDatabase, def: FunctionId) -> Binders<Ty> { |
1041 | let generics = generics(db.upcast(), def.into()); | 1033 | let generics = generics(db.upcast(), def.into()); |
1042 | let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST); | 1034 | let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST); |
1043 | Binders::new(substs.len(), Ty::FnDef(def.into(), substs)) | 1035 | Binders::new( |
1036 | substs.len(), | ||
1037 | TyKind::FnDef(CallableDefId::FunctionId(def).to_chalk(db), substs).intern(&Interner), | ||
1038 | ) | ||
1044 | } | 1039 | } |
1045 | 1040 | ||
1046 | /// Build the declared type of a const. | 1041 | /// Build the declared type of a const. |
@@ -1051,7 +1046,7 @@ fn type_for_const(db: &dyn HirDatabase, def: ConstId) -> Binders<Ty> { | |||
1051 | let ctx = | 1046 | let ctx = |
1052 | TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable); | 1047 | TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable); |
1053 | 1048 | ||
1054 | Binders::new(generics.len(), Ty::from_hir(&ctx, &data.type_ref)) | 1049 | Binders::new(generics.len(), ctx.lower_ty(&data.type_ref)) |
1055 | } | 1050 | } |
1056 | 1051 | ||
1057 | /// Build the declared type of a static. | 1052 | /// Build the declared type of a static. |
@@ -1060,7 +1055,7 @@ fn type_for_static(db: &dyn HirDatabase, def: StaticId) -> Binders<Ty> { | |||
1060 | let resolver = def.resolver(db.upcast()); | 1055 | let resolver = def.resolver(db.upcast()); |
1061 | let ctx = TyLoweringContext::new(db, &resolver); | 1056 | let ctx = TyLoweringContext::new(db, &resolver); |
1062 | 1057 | ||
1063 | Binders::new(0, Ty::from_hir(&ctx, &data.type_ref)) | 1058 | Binders::new(0, ctx.lower_ty(&data.type_ref)) |
1064 | } | 1059 | } |
1065 | 1060 | ||
1066 | fn fn_sig_for_struct_constructor(db: &dyn HirDatabase, def: StructId) -> PolyFnSig { | 1061 | fn fn_sig_for_struct_constructor(db: &dyn HirDatabase, def: StructId) -> PolyFnSig { |
@@ -1069,8 +1064,7 @@ fn fn_sig_for_struct_constructor(db: &dyn HirDatabase, def: StructId) -> PolyFnS | |||
1069 | let resolver = def.resolver(db.upcast()); | 1064 | let resolver = def.resolver(db.upcast()); |
1070 | let ctx = | 1065 | let ctx = |
1071 | TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable); | 1066 | TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable); |
1072 | let params = | 1067 | let params = fields.iter().map(|(_, field)| ctx.lower_ty(&field.type_ref)).collect::<Vec<_>>(); |
1073 | fields.iter().map(|(_, field)| Ty::from_hir(&ctx, &field.type_ref)).collect::<Vec<_>>(); | ||
1074 | let ret = type_for_adt(db, def.into()); | 1068 | let ret = type_for_adt(db, def.into()); |
1075 | Binders::new(ret.num_binders, CallableSig::from_params_and_return(params, ret.value, false)) | 1069 | Binders::new(ret.num_binders, CallableSig::from_params_and_return(params, ret.value, false)) |
1076 | } | 1070 | } |
@@ -1083,7 +1077,10 @@ fn type_for_struct_constructor(db: &dyn HirDatabase, def: StructId) -> Binders<T | |||
1083 | } | 1077 | } |
1084 | let generics = generics(db.upcast(), def.into()); | 1078 | let generics = generics(db.upcast(), def.into()); |
1085 | let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST); | 1079 | let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST); |
1086 | Binders::new(substs.len(), Ty::FnDef(def.into(), substs)) | 1080 | Binders::new( |
1081 | substs.len(), | ||
1082 | TyKind::FnDef(CallableDefId::StructId(def).to_chalk(db), substs).intern(&Interner), | ||
1083 | ) | ||
1087 | } | 1084 | } |
1088 | 1085 | ||
1089 | fn fn_sig_for_enum_variant_constructor(db: &dyn HirDatabase, def: EnumVariantId) -> PolyFnSig { | 1086 | fn fn_sig_for_enum_variant_constructor(db: &dyn HirDatabase, def: EnumVariantId) -> PolyFnSig { |
@@ -1093,8 +1090,7 @@ fn fn_sig_for_enum_variant_constructor(db: &dyn HirDatabase, def: EnumVariantId) | |||
1093 | let resolver = def.parent.resolver(db.upcast()); | 1090 | let resolver = def.parent.resolver(db.upcast()); |
1094 | let ctx = | 1091 | let ctx = |
1095 | TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable); | 1092 | TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable); |
1096 | let params = | 1093 | let params = fields.iter().map(|(_, field)| ctx.lower_ty(&field.type_ref)).collect::<Vec<_>>(); |
1097 | fields.iter().map(|(_, field)| Ty::from_hir(&ctx, &field.type_ref)).collect::<Vec<_>>(); | ||
1098 | let ret = type_for_adt(db, def.parent.into()); | 1094 | let ret = type_for_adt(db, def.parent.into()); |
1099 | Binders::new(ret.num_binders, CallableSig::from_params_and_return(params, ret.value, false)) | 1095 | Binders::new(ret.num_binders, CallableSig::from_params_and_return(params, ret.value, false)) |
1100 | } | 1096 | } |
@@ -1108,7 +1104,10 @@ fn type_for_enum_variant_constructor(db: &dyn HirDatabase, def: EnumVariantId) - | |||
1108 | } | 1104 | } |
1109 | let generics = generics(db.upcast(), def.parent.into()); | 1105 | let generics = generics(db.upcast(), def.parent.into()); |
1110 | let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST); | 1106 | let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST); |
1111 | Binders::new(substs.len(), Ty::FnDef(def.into(), substs)) | 1107 | Binders::new( |
1108 | substs.len(), | ||
1109 | TyKind::FnDef(CallableDefId::EnumVariantId(def).to_chalk(db), substs).intern(&Interner), | ||
1110 | ) | ||
1112 | } | 1111 | } |
1113 | 1112 | ||
1114 | fn type_for_adt(db: &dyn HirDatabase, adt: AdtId) -> Binders<Ty> { | 1113 | fn type_for_adt(db: &dyn HirDatabase, adt: AdtId) -> Binders<Ty> { |
@@ -1123,11 +1122,11 @@ fn type_for_type_alias(db: &dyn HirDatabase, t: TypeAliasId) -> Binders<Ty> { | |||
1123 | let ctx = | 1122 | let ctx = |
1124 | TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable); | 1123 | TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable); |
1125 | if db.type_alias_data(t).is_extern { | 1124 | if db.type_alias_data(t).is_extern { |
1126 | Binders::new(0, Ty::ForeignType(t)) | 1125 | Binders::new(0, TyKind::ForeignType(crate::to_foreign_def_id(t)).intern(&Interner)) |
1127 | } else { | 1126 | } else { |
1128 | let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST); | 1127 | let substs = Substs::bound_vars(&generics, DebruijnIndex::INNERMOST); |
1129 | let type_ref = &db.type_alias_data(t).type_ref; | 1128 | let type_ref = &db.type_alias_data(t).type_ref; |
1130 | let inner = Ty::from_hir(&ctx, type_ref.as_ref().unwrap_or(&TypeRef::Error)); | 1129 | let inner = ctx.lower_ty(type_ref.as_ref().unwrap_or(&TypeRef::Error)); |
1131 | Binders::new(substs.len(), inner) | 1130 | Binders::new(substs.len(), inner) |
1132 | } | 1131 | } |
1133 | } | 1132 | } |
@@ -1199,7 +1198,7 @@ pub(crate) fn ty_recover(db: &dyn HirDatabase, _cycle: &[String], def: &TyDefId) | |||
1199 | TyDefId::AdtId(it) => generics(db.upcast(), it.into()).len(), | 1198 | TyDefId::AdtId(it) => generics(db.upcast(), it.into()).len(), |
1200 | TyDefId::TypeAliasId(it) => generics(db.upcast(), it.into()).len(), | 1199 | TyDefId::TypeAliasId(it) => generics(db.upcast(), it.into()).len(), |
1201 | }; | 1200 | }; |
1202 | Binders::new(num_binders, Ty::Unknown) | 1201 | Binders::new(num_binders, TyKind::Unknown.intern(&Interner)) |
1203 | } | 1202 | } |
1204 | 1203 | ||
1205 | pub(crate) fn value_ty_query(db: &dyn HirDatabase, def: ValueTyDefId) -> Binders<Ty> { | 1204 | pub(crate) fn value_ty_query(db: &dyn HirDatabase, def: ValueTyDefId) -> Binders<Ty> { |
@@ -1219,7 +1218,7 @@ pub(crate) fn impl_self_ty_query(db: &dyn HirDatabase, impl_id: ImplId) -> Binde | |||
1219 | let generics = generics(db.upcast(), impl_id.into()); | 1218 | let generics = generics(db.upcast(), impl_id.into()); |
1220 | let ctx = | 1219 | let ctx = |
1221 | TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable); | 1220 | TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable); |
1222 | Binders::new(generics.len(), Ty::from_hir(&ctx, &impl_data.target_type)) | 1221 | Binders::new(generics.len(), ctx.lower_ty(&impl_data.target_type)) |
1223 | } | 1222 | } |
1224 | 1223 | ||
1225 | pub(crate) fn const_param_ty_query(db: &dyn HirDatabase, def: ConstParamId) -> Ty { | 1224 | pub(crate) fn const_param_ty_query(db: &dyn HirDatabase, def: ConstParamId) -> Ty { |
@@ -1228,7 +1227,7 @@ pub(crate) fn const_param_ty_query(db: &dyn HirDatabase, def: ConstParamId) -> T | |||
1228 | let resolver = def.parent.resolver(db.upcast()); | 1227 | let resolver = def.parent.resolver(db.upcast()); |
1229 | let ctx = TyLoweringContext::new(db, &resolver); | 1228 | let ctx = TyLoweringContext::new(db, &resolver); |
1230 | 1229 | ||
1231 | Ty::from_hir(&ctx, &data.ty) | 1230 | ctx.lower_ty(&data.ty) |
1232 | } | 1231 | } |
1233 | 1232 | ||
1234 | pub(crate) fn impl_self_ty_recover( | 1233 | pub(crate) fn impl_self_ty_recover( |
@@ -1237,7 +1236,7 @@ pub(crate) fn impl_self_ty_recover( | |||
1237 | impl_id: &ImplId, | 1236 | impl_id: &ImplId, |
1238 | ) -> Binders<Ty> { | 1237 | ) -> Binders<Ty> { |
1239 | let generics = generics(db.upcast(), (*impl_id).into()); | 1238 | let generics = generics(db.upcast(), (*impl_id).into()); |
1240 | Binders::new(generics.len(), Ty::Unknown) | 1239 | Binders::new(generics.len(), TyKind::Unknown.intern(&Interner)) |
1241 | } | 1240 | } |
1242 | 1241 | ||
1243 | pub(crate) fn impl_trait_query(db: &dyn HirDatabase, impl_id: ImplId) -> Option<Binders<TraitRef>> { | 1242 | pub(crate) fn impl_trait_query(db: &dyn HirDatabase, impl_id: ImplId) -> Option<Binders<TraitRef>> { |
@@ -1247,10 +1246,7 @@ pub(crate) fn impl_trait_query(db: &dyn HirDatabase, impl_id: ImplId) -> Option< | |||
1247 | TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable); | 1246 | TyLoweringContext::new(db, &resolver).with_type_param_mode(TypeParamLoweringMode::Variable); |
1248 | let self_ty = db.impl_self_ty(impl_id); | 1247 | let self_ty = db.impl_self_ty(impl_id); |
1249 | let target_trait = impl_data.target_trait.as_ref()?; | 1248 | let target_trait = impl_data.target_trait.as_ref()?; |
1250 | Some(Binders::new( | 1249 | Some(Binders::new(self_ty.num_binders, ctx.lower_trait_ref(target_trait, Some(self_ty.value))?)) |
1251 | self_ty.num_binders, | ||
1252 | TraitRef::from_hir(&ctx, target_trait, Some(self_ty.value))?, | ||
1253 | )) | ||
1254 | } | 1250 | } |
1255 | 1251 | ||
1256 | pub(crate) fn return_type_impl_traits( | 1252 | pub(crate) fn return_type_impl_traits( |
@@ -1263,7 +1259,7 @@ pub(crate) fn return_type_impl_traits( | |||
1263 | let ctx_ret = TyLoweringContext::new(db, &resolver) | 1259 | let ctx_ret = TyLoweringContext::new(db, &resolver) |
1264 | .with_impl_trait_mode(ImplTraitLoweringMode::Opaque) | 1260 | .with_impl_trait_mode(ImplTraitLoweringMode::Opaque) |
1265 | .with_type_param_mode(TypeParamLoweringMode::Variable); | 1261 | .with_type_param_mode(TypeParamLoweringMode::Variable); |
1266 | let _ret = Ty::from_hir(&ctx_ret, &data.ret_type); | 1262 | let _ret = (&ctx_ret).lower_ty(&data.ret_type); |
1267 | let generics = generics(db.upcast(), def.into()); | 1263 | let generics = generics(db.upcast(), def.into()); |
1268 | let num_binders = generics.len(); | 1264 | let num_binders = generics.len(); |
1269 | let return_type_impl_traits = | 1265 | let return_type_impl_traits = |
diff --git a/crates/hir_ty/src/method_resolution.rs b/crates/hir_ty/src/method_resolution.rs index d57c6de70..c7055bee5 100644 --- a/crates/hir_ty/src/method_resolution.rs +++ b/crates/hir_ty/src/method_resolution.rs | |||
@@ -9,7 +9,7 @@ use base_db::CrateId; | |||
9 | use chalk_ir::Mutability; | 9 | use chalk_ir::Mutability; |
10 | use hir_def::{ | 10 | use hir_def::{ |
11 | lang_item::LangItemTarget, AssocContainerId, AssocItemId, FunctionId, GenericDefId, HasModule, | 11 | lang_item::LangItemTarget, AssocContainerId, AssocItemId, FunctionId, GenericDefId, HasModule, |
12 | ImplId, Lookup, ModuleId, TraitId, TypeAliasId, | 12 | ImplId, Lookup, ModuleId, TraitId, |
13 | }; | 13 | }; |
14 | use hir_expand::name::Name; | 14 | use hir_expand::name::Name; |
15 | use rustc_hash::{FxHashMap, FxHashSet}; | 15 | use rustc_hash::{FxHashMap, FxHashSet}; |
@@ -17,10 +17,11 @@ use rustc_hash::{FxHashMap, FxHashSet}; | |||
17 | use crate::{ | 17 | use crate::{ |
18 | autoderef, | 18 | autoderef, |
19 | db::HirDatabase, | 19 | db::HirDatabase, |
20 | from_foreign_def_id, | ||
20 | primitive::{self, FloatTy, IntTy, UintTy}, | 21 | primitive::{self, FloatTy, IntTy, UintTy}, |
21 | utils::all_super_traits, | 22 | utils::all_super_traits, |
22 | AdtId, Canonical, DebruijnIndex, FnPointer, FnSig, InEnvironment, Scalar, Substs, | 23 | AdtId, Canonical, DebruijnIndex, FnPointer, FnSig, ForeignDefId, InEnvironment, Interner, |
23 | TraitEnvironment, TraitRef, Ty, TypeWalk, | 24 | Scalar, Substs, TraitEnvironment, TraitRef, Ty, TyKind, TypeWalk, |
24 | }; | 25 | }; |
25 | 26 | ||
26 | /// This is used as a key for indexing impls. | 27 | /// This is used as a key for indexing impls. |
@@ -35,7 +36,7 @@ pub enum TyFingerprint { | |||
35 | Adt(hir_def::AdtId), | 36 | Adt(hir_def::AdtId), |
36 | Dyn(TraitId), | 37 | Dyn(TraitId), |
37 | Tuple(usize), | 38 | Tuple(usize), |
38 | ForeignType(TypeAliasId), | 39 | ForeignType(ForeignDefId), |
39 | FnPtr(usize, FnSig), | 40 | FnPtr(usize, FnSig), |
40 | } | 41 | } |
41 | 42 | ||
@@ -44,18 +45,20 @@ impl TyFingerprint { | |||
44 | /// have impls: if we have some `struct S`, we can have an `impl S`, but not | 45 | /// have impls: if we have some `struct S`, we can have an `impl S`, but not |
45 | /// `impl &S`. Hence, this will return `None` for reference types and such. | 46 | /// `impl &S`. Hence, this will return `None` for reference types and such. |
46 | pub(crate) fn for_impl(ty: &Ty) -> Option<TyFingerprint> { | 47 | pub(crate) fn for_impl(ty: &Ty) -> Option<TyFingerprint> { |
47 | let fp = match ty { | 48 | let fp = match *ty.interned(&Interner) { |
48 | &Ty::Str => TyFingerprint::Str, | 49 | TyKind::Str => TyFingerprint::Str, |
49 | &Ty::Never => TyFingerprint::Never, | 50 | TyKind::Never => TyFingerprint::Never, |
50 | &Ty::Slice(..) => TyFingerprint::Slice, | 51 | TyKind::Slice(..) => TyFingerprint::Slice, |
51 | &Ty::Array(..) => TyFingerprint::Array, | 52 | TyKind::Array(..) => TyFingerprint::Array, |
52 | &Ty::Scalar(scalar) => TyFingerprint::Scalar(scalar), | 53 | TyKind::Scalar(scalar) => TyFingerprint::Scalar(scalar), |
53 | &Ty::Adt(AdtId(adt), _) => TyFingerprint::Adt(adt), | 54 | TyKind::Adt(AdtId(adt), _) => TyFingerprint::Adt(adt), |
54 | &Ty::Tuple(cardinality, _) => TyFingerprint::Tuple(cardinality), | 55 | TyKind::Tuple(cardinality, _) => TyFingerprint::Tuple(cardinality), |
55 | &Ty::Raw(mutability, ..) => TyFingerprint::RawPtr(mutability), | 56 | TyKind::Raw(mutability, ..) => TyFingerprint::RawPtr(mutability), |
56 | &Ty::ForeignType(alias_id, ..) => TyFingerprint::ForeignType(alias_id), | 57 | TyKind::ForeignType(alias_id, ..) => TyFingerprint::ForeignType(alias_id), |
57 | &Ty::Function(FnPointer { num_args, sig, .. }) => TyFingerprint::FnPtr(num_args, sig), | 58 | TyKind::Function(FnPointer { num_args, sig, .. }) => { |
58 | Ty::Dyn(_) => ty.dyn_trait().map(|trait_| TyFingerprint::Dyn(trait_))?, | 59 | TyFingerprint::FnPtr(num_args, sig) |
60 | } | ||
61 | TyKind::Dyn(_) => ty.dyn_trait().map(|trait_| TyFingerprint::Dyn(trait_))?, | ||
59 | _ => return None, | 62 | _ => return None, |
60 | }; | 63 | }; |
61 | Some(fp) | 64 | Some(fp) |
@@ -230,31 +233,33 @@ impl Ty { | |||
230 | 233 | ||
231 | let mod_to_crate_ids = |module: ModuleId| Some(std::iter::once(module.krate()).collect()); | 234 | let mod_to_crate_ids = |module: ModuleId| Some(std::iter::once(module.krate()).collect()); |
232 | 235 | ||
233 | let lang_item_targets = match self { | 236 | let lang_item_targets = match self.interned(&Interner) { |
234 | Ty::Adt(AdtId(def_id), _) => { | 237 | TyKind::Adt(AdtId(def_id), _) => { |
235 | return mod_to_crate_ids(def_id.module(db.upcast())); | 238 | return mod_to_crate_ids(def_id.module(db.upcast())); |
236 | } | 239 | } |
237 | Ty::ForeignType(type_alias_id) => { | 240 | TyKind::ForeignType(id) => { |
238 | return mod_to_crate_ids(type_alias_id.lookup(db.upcast()).module(db.upcast())); | 241 | return mod_to_crate_ids( |
242 | from_foreign_def_id(*id).lookup(db.upcast()).module(db.upcast()), | ||
243 | ); | ||
239 | } | 244 | } |
240 | Ty::Scalar(Scalar::Bool) => lang_item_crate!("bool"), | 245 | TyKind::Scalar(Scalar::Bool) => lang_item_crate!("bool"), |
241 | Ty::Scalar(Scalar::Char) => lang_item_crate!("char"), | 246 | TyKind::Scalar(Scalar::Char) => lang_item_crate!("char"), |
242 | Ty::Scalar(Scalar::Float(f)) => match f { | 247 | TyKind::Scalar(Scalar::Float(f)) => match f { |
243 | // There are two lang items: one in libcore (fXX) and one in libstd (fXX_runtime) | 248 | // There are two lang items: one in libcore (fXX) and one in libstd (fXX_runtime) |
244 | FloatTy::F32 => lang_item_crate!("f32", "f32_runtime"), | 249 | FloatTy::F32 => lang_item_crate!("f32", "f32_runtime"), |
245 | FloatTy::F64 => lang_item_crate!("f64", "f64_runtime"), | 250 | FloatTy::F64 => lang_item_crate!("f64", "f64_runtime"), |
246 | }, | 251 | }, |
247 | &Ty::Scalar(Scalar::Int(t)) => { | 252 | &TyKind::Scalar(Scalar::Int(t)) => { |
248 | lang_item_crate!(primitive::int_ty_to_string(t)) | 253 | lang_item_crate!(primitive::int_ty_to_string(t)) |
249 | } | 254 | } |
250 | &Ty::Scalar(Scalar::Uint(t)) => { | 255 | &TyKind::Scalar(Scalar::Uint(t)) => { |
251 | lang_item_crate!(primitive::uint_ty_to_string(t)) | 256 | lang_item_crate!(primitive::uint_ty_to_string(t)) |
252 | } | 257 | } |
253 | Ty::Str => lang_item_crate!("str_alloc", "str"), | 258 | TyKind::Str => lang_item_crate!("str_alloc", "str"), |
254 | Ty::Slice(_) => lang_item_crate!("slice_alloc", "slice"), | 259 | TyKind::Slice(_) => lang_item_crate!("slice_alloc", "slice"), |
255 | Ty::Raw(Mutability::Not, _) => lang_item_crate!("const_ptr"), | 260 | TyKind::Raw(Mutability::Not, _) => lang_item_crate!("const_ptr"), |
256 | Ty::Raw(Mutability::Mut, _) => lang_item_crate!("mut_ptr"), | 261 | TyKind::Raw(Mutability::Mut, _) => lang_item_crate!("mut_ptr"), |
257 | Ty::Dyn(_) => { | 262 | TyKind::Dyn(_) => { |
258 | return self.dyn_trait().and_then(|trait_| { | 263 | return self.dyn_trait().and_then(|trait_| { |
259 | mod_to_crate_ids(GenericDefId::TraitId(trait_).module(db.upcast())) | 264 | mod_to_crate_ids(GenericDefId::TraitId(trait_).module(db.upcast())) |
260 | }); | 265 | }); |
@@ -430,7 +435,8 @@ fn iterate_method_candidates_with_autoref( | |||
430 | } | 435 | } |
431 | let refed = Canonical { | 436 | let refed = Canonical { |
432 | kinds: deref_chain[0].kinds.clone(), | 437 | kinds: deref_chain[0].kinds.clone(), |
433 | value: Ty::Ref(Mutability::Not, Substs::single(deref_chain[0].value.clone())), | 438 | value: TyKind::Ref(Mutability::Not, Substs::single(deref_chain[0].value.clone())) |
439 | .intern(&Interner), | ||
434 | }; | 440 | }; |
435 | if iterate_method_candidates_by_receiver( | 441 | if iterate_method_candidates_by_receiver( |
436 | &refed, | 442 | &refed, |
@@ -446,7 +452,8 @@ fn iterate_method_candidates_with_autoref( | |||
446 | } | 452 | } |
447 | let ref_muted = Canonical { | 453 | let ref_muted = Canonical { |
448 | kinds: deref_chain[0].kinds.clone(), | 454 | kinds: deref_chain[0].kinds.clone(), |
449 | value: Ty::Ref(Mutability::Mut, Substs::single(deref_chain[0].value.clone())), | 455 | value: TyKind::Ref(Mutability::Mut, Substs::single(deref_chain[0].value.clone())) |
456 | .intern(&Interner), | ||
450 | }; | 457 | }; |
451 | if iterate_method_candidates_by_receiver( | 458 | if iterate_method_candidates_by_receiver( |
452 | &ref_muted, | 459 | &ref_muted, |
@@ -526,7 +533,7 @@ fn iterate_trait_method_candidates( | |||
526 | // if ty is `dyn Trait`, the trait doesn't need to be in scope | 533 | // if ty is `dyn Trait`, the trait doesn't need to be in scope |
527 | let inherent_trait = | 534 | let inherent_trait = |
528 | self_ty.value.dyn_trait().into_iter().flat_map(|t| all_super_traits(db.upcast(), t)); | 535 | self_ty.value.dyn_trait().into_iter().flat_map(|t| all_super_traits(db.upcast(), t)); |
529 | let env_traits = if let Ty::Placeholder(_) = self_ty.value { | 536 | let env_traits = if let TyKind::Placeholder(_) = self_ty.value.interned(&Interner) { |
530 | // if we have `T: Trait` in the param env, the trait doesn't need to be in scope | 537 | // if we have `T: Trait` in the param env, the trait doesn't need to be in scope |
531 | env.traits_in_scope_from_clauses(&self_ty.value) | 538 | env.traits_in_scope_from_clauses(&self_ty.value) |
532 | .flat_map(|t| all_super_traits(db.upcast(), t)) | 539 | .flat_map(|t| all_super_traits(db.upcast(), t)) |
@@ -679,13 +686,13 @@ pub(crate) fn inherent_impl_substs( | |||
679 | } | 686 | } |
680 | 687 | ||
681 | /// This replaces any 'free' Bound vars in `s` (i.e. those with indices past | 688 | /// This replaces any 'free' Bound vars in `s` (i.e. those with indices past |
682 | /// num_vars_to_keep) by `Ty::Unknown`. | 689 | /// num_vars_to_keep) by `TyKind::Unknown`. |
683 | fn fallback_bound_vars(s: Substs, num_vars_to_keep: usize) -> Substs { | 690 | fn fallback_bound_vars(s: Substs, num_vars_to_keep: usize) -> Substs { |
684 | s.fold_binders( | 691 | s.fold_binders( |
685 | &mut |ty, binders| { | 692 | &mut |ty, binders| { |
686 | if let Ty::BoundVar(bound) = &ty { | 693 | if let TyKind::BoundVar(bound) = ty.interned(&Interner) { |
687 | if bound.index >= num_vars_to_keep && bound.debruijn >= binders { | 694 | if bound.index >= num_vars_to_keep && bound.debruijn >= binders { |
688 | Ty::Unknown | 695 | TyKind::Unknown.intern(&Interner) |
689 | } else { | 696 | } else { |
690 | ty | 697 | ty |
691 | } | 698 | } |
@@ -772,9 +779,11 @@ fn autoderef_method_receiver( | |||
772 | ) -> Vec<Canonical<Ty>> { | 779 | ) -> Vec<Canonical<Ty>> { |
773 | let mut deref_chain: Vec<_> = autoderef::autoderef(db, Some(krate), ty).collect(); | 780 | let mut deref_chain: Vec<_> = autoderef::autoderef(db, Some(krate), ty).collect(); |
774 | // As a last step, we can do array unsizing (that's the only unsizing that rustc does for method receivers!) | 781 | // As a last step, we can do array unsizing (that's the only unsizing that rustc does for method receivers!) |
775 | if let Some(Ty::Array(parameters)) = deref_chain.last().map(|ty| &ty.value) { | 782 | if let Some(TyKind::Array(parameters)) = |
783 | deref_chain.last().map(|ty| ty.value.interned(&Interner)) | ||
784 | { | ||
776 | let kinds = deref_chain.last().unwrap().kinds.clone(); | 785 | let kinds = deref_chain.last().unwrap().kinds.clone(); |
777 | let unsized_ty = Ty::Slice(parameters.clone()); | 786 | let unsized_ty = TyKind::Slice(parameters.clone()).intern(&Interner); |
778 | deref_chain.push(Canonical { value: unsized_ty, kinds }) | 787 | deref_chain.push(Canonical { value: unsized_ty, kinds }) |
779 | } | 788 | } |
780 | deref_chain | 789 | deref_chain |
diff --git a/crates/hir_ty/src/op.rs b/crates/hir_ty/src/op.rs index bb9b8bbfc..527c5cbbd 100644 --- a/crates/hir_ty/src/op.rs +++ b/crates/hir_ty/src/op.rs | |||
@@ -2,51 +2,55 @@ | |||
2 | use chalk_ir::TyVariableKind; | 2 | use chalk_ir::TyVariableKind; |
3 | use hir_def::expr::{ArithOp, BinaryOp, CmpOp}; | 3 | use hir_def::expr::{ArithOp, BinaryOp, CmpOp}; |
4 | 4 | ||
5 | use crate::{Scalar, Ty}; | 5 | use crate::{Interner, Scalar, Ty, TyKind}; |
6 | 6 | ||
7 | pub(super) fn binary_op_return_ty(op: BinaryOp, lhs_ty: Ty, rhs_ty: Ty) -> Ty { | 7 | pub(super) fn binary_op_return_ty(op: BinaryOp, lhs_ty: Ty, rhs_ty: Ty) -> Ty { |
8 | match op { | 8 | match op { |
9 | BinaryOp::LogicOp(_) | BinaryOp::CmpOp(_) => Ty::Scalar(Scalar::Bool), | 9 | BinaryOp::LogicOp(_) | BinaryOp::CmpOp(_) => TyKind::Scalar(Scalar::Bool).intern(&Interner), |
10 | BinaryOp::Assignment { .. } => Ty::unit(), | 10 | BinaryOp::Assignment { .. } => Ty::unit(), |
11 | BinaryOp::ArithOp(ArithOp::Shl) | BinaryOp::ArithOp(ArithOp::Shr) => match lhs_ty { | 11 | BinaryOp::ArithOp(ArithOp::Shl) | BinaryOp::ArithOp(ArithOp::Shr) => { |
12 | Ty::Scalar(Scalar::Int(_)) | 12 | match lhs_ty.interned(&Interner) { |
13 | | Ty::Scalar(Scalar::Uint(_)) | 13 | TyKind::Scalar(Scalar::Int(_)) |
14 | | Ty::Scalar(Scalar::Float(_)) => lhs_ty, | 14 | | TyKind::Scalar(Scalar::Uint(_)) |
15 | Ty::InferenceVar(_, TyVariableKind::Integer) | 15 | | TyKind::Scalar(Scalar::Float(_)) => lhs_ty, |
16 | | Ty::InferenceVar(_, TyVariableKind::Float) => lhs_ty, | 16 | TyKind::InferenceVar(_, TyVariableKind::Integer) |
17 | _ => Ty::Unknown, | 17 | | TyKind::InferenceVar(_, TyVariableKind::Float) => lhs_ty, |
18 | }, | 18 | _ => TyKind::Unknown.intern(&Interner), |
19 | BinaryOp::ArithOp(_) => match rhs_ty { | 19 | } |
20 | Ty::Scalar(Scalar::Int(_)) | 20 | } |
21 | | Ty::Scalar(Scalar::Uint(_)) | 21 | BinaryOp::ArithOp(_) => match rhs_ty.interned(&Interner) { |
22 | | Ty::Scalar(Scalar::Float(_)) => rhs_ty, | 22 | TyKind::Scalar(Scalar::Int(_)) |
23 | Ty::InferenceVar(_, TyVariableKind::Integer) | 23 | | TyKind::Scalar(Scalar::Uint(_)) |
24 | | Ty::InferenceVar(_, TyVariableKind::Float) => rhs_ty, | 24 | | TyKind::Scalar(Scalar::Float(_)) => rhs_ty, |
25 | _ => Ty::Unknown, | 25 | TyKind::InferenceVar(_, TyVariableKind::Integer) |
26 | | TyKind::InferenceVar(_, TyVariableKind::Float) => rhs_ty, | ||
27 | _ => TyKind::Unknown.intern(&Interner), | ||
26 | }, | 28 | }, |
27 | } | 29 | } |
28 | } | 30 | } |
29 | 31 | ||
30 | pub(super) fn binary_op_rhs_expectation(op: BinaryOp, lhs_ty: Ty) -> Ty { | 32 | pub(super) fn binary_op_rhs_expectation(op: BinaryOp, lhs_ty: Ty) -> Ty { |
31 | match op { | 33 | match op { |
32 | BinaryOp::LogicOp(..) => Ty::Scalar(Scalar::Bool), | 34 | BinaryOp::LogicOp(..) => TyKind::Scalar(Scalar::Bool).intern(&Interner), |
33 | BinaryOp::Assignment { op: None } => lhs_ty, | 35 | BinaryOp::Assignment { op: None } => lhs_ty, |
34 | BinaryOp::CmpOp(CmpOp::Eq { .. }) => match lhs_ty { | 36 | BinaryOp::CmpOp(CmpOp::Eq { .. }) => match lhs_ty.interned(&Interner) { |
35 | Ty::Scalar(_) | Ty::Str => lhs_ty, | 37 | TyKind::Scalar(_) | TyKind::Str => lhs_ty, |
36 | Ty::InferenceVar(_, TyVariableKind::Integer) | 38 | TyKind::InferenceVar(_, TyVariableKind::Integer) |
37 | | Ty::InferenceVar(_, TyVariableKind::Float) => lhs_ty, | 39 | | TyKind::InferenceVar(_, TyVariableKind::Float) => lhs_ty, |
38 | _ => Ty::Unknown, | 40 | _ => TyKind::Unknown.intern(&Interner), |
39 | }, | 41 | }, |
40 | BinaryOp::ArithOp(ArithOp::Shl) | BinaryOp::ArithOp(ArithOp::Shr) => Ty::Unknown, | 42 | BinaryOp::ArithOp(ArithOp::Shl) | BinaryOp::ArithOp(ArithOp::Shr) => { |
43 | TyKind::Unknown.intern(&Interner) | ||
44 | } | ||
41 | BinaryOp::CmpOp(CmpOp::Ord { .. }) | 45 | BinaryOp::CmpOp(CmpOp::Ord { .. }) |
42 | | BinaryOp::Assignment { op: Some(_) } | 46 | | BinaryOp::Assignment { op: Some(_) } |
43 | | BinaryOp::ArithOp(_) => match lhs_ty { | 47 | | BinaryOp::ArithOp(_) => match lhs_ty.interned(&Interner) { |
44 | Ty::Scalar(Scalar::Int(_)) | 48 | TyKind::Scalar(Scalar::Int(_)) |
45 | | Ty::Scalar(Scalar::Uint(_)) | 49 | | TyKind::Scalar(Scalar::Uint(_)) |
46 | | Ty::Scalar(Scalar::Float(_)) => lhs_ty, | 50 | | TyKind::Scalar(Scalar::Float(_)) => lhs_ty, |
47 | Ty::InferenceVar(_, TyVariableKind::Integer) | 51 | TyKind::InferenceVar(_, TyVariableKind::Integer) |
48 | | Ty::InferenceVar(_, TyVariableKind::Float) => lhs_ty, | 52 | | TyKind::InferenceVar(_, TyVariableKind::Float) => lhs_ty, |
49 | _ => Ty::Unknown, | 53 | _ => TyKind::Unknown.intern(&Interner), |
50 | }, | 54 | }, |
51 | } | 55 | } |
52 | } | 56 | } |
diff --git a/crates/hir_ty/src/traits.rs b/crates/hir_ty/src/traits.rs index 27f350f70..edfafdff8 100644 --- a/crates/hir_ty/src/traits.rs +++ b/crates/hir_ty/src/traits.rs | |||
@@ -10,7 +10,9 @@ use stdx::panic_context; | |||
10 | 10 | ||
11 | use crate::{db::HirDatabase, DebruijnIndex, Substs}; | 11 | use crate::{db::HirDatabase, DebruijnIndex, Substs}; |
12 | 12 | ||
13 | use super::{Canonical, GenericPredicate, HirDisplay, ProjectionTy, TraitRef, Ty, TypeWalk}; | 13 | use super::{ |
14 | Canonical, GenericPredicate, HirDisplay, ProjectionTy, TraitRef, Ty, TyKind, TypeWalk, | ||
15 | }; | ||
14 | 16 | ||
15 | use self::chalk::{from_chalk, Interner, ToChalk}; | 17 | use self::chalk::{from_chalk, Interner, ToChalk}; |
16 | 18 | ||
@@ -61,6 +63,15 @@ impl TraitEnvironment { | |||
61 | } | 63 | } |
62 | } | 64 | } |
63 | 65 | ||
66 | impl Default for TraitEnvironment { | ||
67 | fn default() -> Self { | ||
68 | TraitEnvironment { | ||
69 | traits_from_clauses: Vec::new(), | ||
70 | env: chalk_ir::Environment::new(&Interner), | ||
71 | } | ||
72 | } | ||
73 | } | ||
74 | |||
64 | /// Something (usually a goal), along with an environment. | 75 | /// Something (usually a goal), along with an environment. |
65 | #[derive(Clone, Debug, PartialEq, Eq, Hash)] | 76 | #[derive(Clone, Debug, PartialEq, Eq, Hash)] |
66 | pub struct InEnvironment<T> { | 77 | pub struct InEnvironment<T> { |
@@ -132,7 +143,7 @@ pub(crate) fn trait_solve_query( | |||
132 | log::info!("trait_solve_query({})", goal.value.value.display(db)); | 143 | log::info!("trait_solve_query({})", goal.value.value.display(db)); |
133 | 144 | ||
134 | if let Obligation::Projection(pred) = &goal.value.value { | 145 | if let Obligation::Projection(pred) = &goal.value.value { |
135 | if let Ty::BoundVar(_) = &pred.projection_ty.parameters[0] { | 146 | if let TyKind::BoundVar(_) = &pred.projection_ty.parameters[0].interned(&Interner) { |
136 | // Hack: don't ask Chalk to normalize with an unknown self type, it'll say that's impossible | 147 | // Hack: don't ask Chalk to normalize with an unknown self type, it'll say that's impossible |
137 | return Some(Solution::Ambig(Guidance::Unknown)); | 148 | return Some(Solution::Ambig(Guidance::Unknown)); |
138 | } | 149 | } |
diff --git a/crates/hir_ty/src/traits/chalk.rs b/crates/hir_ty/src/traits/chalk.rs index 1a2a3a8c7..ef1e6b2df 100644 --- a/crates/hir_ty/src/traits/chalk.rs +++ b/crates/hir_ty/src/traits/chalk.rs | |||
@@ -17,16 +17,18 @@ use super::ChalkContext; | |||
17 | use crate::{ | 17 | use crate::{ |
18 | db::HirDatabase, | 18 | db::HirDatabase, |
19 | display::HirDisplay, | 19 | display::HirDisplay, |
20 | from_assoc_type_id, | ||
20 | method_resolution::{TyFingerprint, ALL_FLOAT_FPS, ALL_INT_FPS}, | 21 | method_resolution::{TyFingerprint, ALL_FLOAT_FPS, ALL_INT_FPS}, |
22 | to_assoc_type_id, | ||
21 | utils::generics, | 23 | utils::generics, |
22 | BoundVar, CallableDefId, CallableSig, DebruijnIndex, GenericPredicate, ProjectionPredicate, | 24 | BoundVar, CallableDefId, CallableSig, DebruijnIndex, FnDefId, GenericPredicate, |
23 | ProjectionTy, Substs, TraitRef, Ty, | 25 | ProjectionPredicate, ProjectionTy, Substs, TraitRef, Ty, TyKind, |
24 | }; | 26 | }; |
25 | use mapping::{ | 27 | use mapping::{ |
26 | convert_where_clauses, generic_predicate_to_inline_bound, make_binders, TypeAliasAsAssocType, | 28 | convert_where_clauses, generic_predicate_to_inline_bound, make_binders, TypeAliasAsValue, |
27 | TypeAliasAsValue, | ||
28 | }; | 29 | }; |
29 | 30 | ||
31 | pub use self::interner::Interner; | ||
30 | pub(crate) use self::interner::*; | 32 | pub(crate) use self::interner::*; |
31 | 33 | ||
32 | pub(super) mod tls; | 34 | pub(super) mod tls; |
@@ -90,7 +92,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> { | |||
90 | ty: &Ty, | 92 | ty: &Ty, |
91 | binders: &CanonicalVarKinds<Interner>, | 93 | binders: &CanonicalVarKinds<Interner>, |
92 | ) -> Option<chalk_ir::TyVariableKind> { | 94 | ) -> Option<chalk_ir::TyVariableKind> { |
93 | if let Ty::BoundVar(bv) = ty { | 95 | if let TyKind::BoundVar(bv) = ty.interned(&Interner) { |
94 | let binders = binders.as_slice(&Interner); | 96 | let binders = binders.as_slice(&Interner); |
95 | if bv.debruijn == DebruijnIndex::INNERMOST { | 97 | if bv.debruijn == DebruijnIndex::INNERMOST { |
96 | if let chalk_ir::VariableKind::Ty(tk) = binders[bv.index].kind { | 98 | if let chalk_ir::VariableKind::Ty(tk) = binders[bv.index].kind { |
@@ -175,10 +177,9 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> { | |||
175 | } | 177 | } |
176 | 178 | ||
177 | fn opaque_ty_data(&self, id: chalk_ir::OpaqueTyId<Interner>) -> Arc<OpaqueTyDatum> { | 179 | fn opaque_ty_data(&self, id: chalk_ir::OpaqueTyId<Interner>) -> Arc<OpaqueTyDatum> { |
178 | let interned_id = crate::db::InternedOpaqueTyId::from(id); | 180 | let full_id = self.db.lookup_intern_impl_trait_id(id.into()); |
179 | let full_id = self.db.lookup_intern_impl_trait_id(interned_id); | ||
180 | let bound = match full_id { | 181 | let bound = match full_id { |
181 | crate::OpaqueTyId::ReturnTypeImplTrait(func, idx) => { | 182 | crate::ImplTraitId::ReturnTypeImplTrait(func, idx) => { |
182 | let datas = self | 183 | let datas = self |
183 | .db | 184 | .db |
184 | .return_type_impl_traits(func) | 185 | .return_type_impl_traits(func) |
@@ -200,7 +201,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> { | |||
200 | let num_vars = datas.num_binders; | 201 | let num_vars = datas.num_binders; |
201 | make_binders(bound, num_vars) | 202 | make_binders(bound, num_vars) |
202 | } | 203 | } |
203 | crate::OpaqueTyId::AsyncBlockTypeImplTrait(..) => { | 204 | crate::ImplTraitId::AsyncBlockTypeImplTrait(..) => { |
204 | if let Some((future_trait, future_output)) = self | 205 | if let Some((future_trait, future_output)) = self |
205 | .db | 206 | .db |
206 | .lang_item(self.krate, "future_trait".into()) | 207 | .lang_item(self.krate, "future_trait".into()) |
@@ -220,21 +221,25 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> { | |||
220 | let impl_bound = GenericPredicate::Implemented(TraitRef { | 221 | let impl_bound = GenericPredicate::Implemented(TraitRef { |
221 | trait_: future_trait, | 222 | trait_: future_trait, |
222 | // Self type as the first parameter. | 223 | // Self type as the first parameter. |
223 | substs: Substs::single(Ty::BoundVar(BoundVar { | 224 | substs: Substs::single( |
224 | debruijn: DebruijnIndex::INNERMOST, | 225 | TyKind::BoundVar(BoundVar { |
225 | index: 0, | 226 | debruijn: DebruijnIndex::INNERMOST, |
226 | })), | 227 | index: 0, |
228 | }) | ||
229 | .intern(&Interner), | ||
230 | ), | ||
227 | }); | 231 | }); |
228 | let proj_bound = GenericPredicate::Projection(ProjectionPredicate { | 232 | let proj_bound = GenericPredicate::Projection(ProjectionPredicate { |
229 | // The parameter of the opaque type. | 233 | // The parameter of the opaque type. |
230 | ty: Ty::BoundVar(BoundVar { debruijn: DebruijnIndex::ONE, index: 0 }), | 234 | ty: TyKind::BoundVar(BoundVar { debruijn: DebruijnIndex::ONE, index: 0 }) |
235 | .intern(&Interner), | ||
231 | projection_ty: ProjectionTy { | 236 | projection_ty: ProjectionTy { |
232 | associated_ty: future_output, | 237 | associated_ty: to_assoc_type_id(future_output), |
233 | // Self type as the first parameter. | 238 | // Self type as the first parameter. |
234 | parameters: Substs::single(Ty::BoundVar(BoundVar::new( | 239 | parameters: Substs::single( |
235 | DebruijnIndex::INNERMOST, | 240 | TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0)) |
236 | 0, | 241 | .intern(&Interner), |
237 | ))), | 242 | ), |
238 | }, | 243 | }, |
239 | }); | 244 | }); |
240 | let bound = OpaqueTyDatumBound { | 245 | let bound = OpaqueTyDatumBound { |
@@ -263,7 +268,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> { | |||
263 | 268 | ||
264 | fn hidden_opaque_type(&self, _id: chalk_ir::OpaqueTyId<Interner>) -> chalk_ir::Ty<Interner> { | 269 | fn hidden_opaque_type(&self, _id: chalk_ir::OpaqueTyId<Interner>) -> chalk_ir::Ty<Interner> { |
265 | // FIXME: actually provide the hidden type; it is relevant for auto traits | 270 | // FIXME: actually provide the hidden type; it is relevant for auto traits |
266 | Ty::Unknown.to_chalk(self.db) | 271 | TyKind::Unknown.intern(&Interner).to_chalk(self.db) |
267 | } | 272 | } |
268 | 273 | ||
269 | fn is_object_safe(&self, _trait_id: chalk_ir::TraitId<Interner>) -> bool { | 274 | fn is_object_safe(&self, _trait_id: chalk_ir::TraitId<Interner>) -> bool { |
@@ -378,7 +383,7 @@ pub(crate) fn associated_ty_data_query( | |||
378 | id: AssocTypeId, | 383 | id: AssocTypeId, |
379 | ) -> Arc<AssociatedTyDatum> { | 384 | ) -> Arc<AssociatedTyDatum> { |
380 | debug!("associated_ty_data {:?}", id); | 385 | debug!("associated_ty_data {:?}", id); |
381 | let type_alias: TypeAliasId = from_chalk::<TypeAliasAsAssocType, _>(db, id).0; | 386 | let type_alias: TypeAliasId = from_assoc_type_id(id); |
382 | let trait_ = match type_alias.lookup(db.upcast()).container { | 387 | let trait_ = match type_alias.lookup(db.upcast()).container { |
383 | AssocContainerId::TraitId(t) => t, | 388 | AssocContainerId::TraitId(t) => t, |
384 | _ => panic!("associated type not in trait"), | 389 | _ => panic!("associated type not in trait"), |
@@ -391,11 +396,12 @@ pub(crate) fn associated_ty_data_query( | |||
391 | let resolver = hir_def::resolver::HasResolver::resolver(type_alias, db.upcast()); | 396 | let resolver = hir_def::resolver::HasResolver::resolver(type_alias, db.upcast()); |
392 | let ctx = crate::TyLoweringContext::new(db, &resolver) | 397 | let ctx = crate::TyLoweringContext::new(db, &resolver) |
393 | .with_type_param_mode(crate::lower::TypeParamLoweringMode::Variable); | 398 | .with_type_param_mode(crate::lower::TypeParamLoweringMode::Variable); |
394 | let self_ty = Ty::BoundVar(crate::BoundVar::new(crate::DebruijnIndex::INNERMOST, 0)); | 399 | let self_ty = |
400 | TyKind::BoundVar(BoundVar::new(crate::DebruijnIndex::INNERMOST, 0)).intern(&Interner); | ||
395 | let bounds = type_alias_data | 401 | let bounds = type_alias_data |
396 | .bounds | 402 | .bounds |
397 | .iter() | 403 | .iter() |
398 | .flat_map(|bound| GenericPredicate::from_type_bound(&ctx, bound, self_ty.clone())) | 404 | .flat_map(|bound| ctx.lower_type_bound(bound, self_ty.clone())) |
399 | .filter_map(|pred| generic_predicate_to_inline_bound(db, &pred, &self_ty)) | 405 | .filter_map(|pred| generic_predicate_to_inline_bound(db, &pred, &self_ty)) |
400 | .map(|bound| make_binders(bound.shifted_in(&Interner), 0)) | 406 | .map(|bound| make_binders(bound.shifted_in(&Interner), 0)) |
401 | .collect(); | 407 | .collect(); |
@@ -432,10 +438,8 @@ pub(crate) fn trait_datum_query( | |||
432 | fundamental: false, | 438 | fundamental: false, |
433 | }; | 439 | }; |
434 | let where_clauses = convert_where_clauses(db, trait_.into(), &bound_vars); | 440 | let where_clauses = convert_where_clauses(db, trait_.into(), &bound_vars); |
435 | let associated_ty_ids = trait_data | 441 | let associated_ty_ids = |
436 | .associated_types() | 442 | trait_data.associated_types().map(|type_alias| to_assoc_type_id(type_alias)).collect(); |
437 | .map(|type_alias| TypeAliasAsAssocType(type_alias).to_chalk(db)) | ||
438 | .collect(); | ||
439 | let trait_datum_bound = rust_ir::TraitDatumBound { where_clauses }; | 443 | let trait_datum_bound = rust_ir::TraitDatumBound { where_clauses }; |
440 | let well_known = | 444 | let well_known = |
441 | lang_attr(db.upcast(), trait_).and_then(|name| well_known_trait_from_lang_attr(&name)); | 445 | lang_attr(db.upcast(), trait_).and_then(|name| well_known_trait_from_lang_attr(&name)); |
@@ -617,7 +621,7 @@ fn type_alias_associated_ty_value( | |||
617 | let value_bound = rust_ir::AssociatedTyValueBound { ty: ty.value.to_chalk(db) }; | 621 | let value_bound = rust_ir::AssociatedTyValueBound { ty: ty.value.to_chalk(db) }; |
618 | let value = rust_ir::AssociatedTyValue { | 622 | let value = rust_ir::AssociatedTyValue { |
619 | impl_id: impl_id.to_chalk(db), | 623 | impl_id: impl_id.to_chalk(db), |
620 | associated_ty_id: TypeAliasAsAssocType(assoc_ty).to_chalk(db), | 624 | associated_ty_id: to_assoc_type_id(assoc_ty), |
621 | value: make_binders(value_bound, ty.num_binders), | 625 | value: make_binders(value_bound, ty.num_binders), |
622 | }; | 626 | }; |
623 | Arc::new(value) | 627 | Arc::new(value) |
@@ -711,14 +715,14 @@ impl From<crate::db::InternedOpaqueTyId> for OpaqueTyId { | |||
711 | } | 715 | } |
712 | } | 716 | } |
713 | 717 | ||
714 | impl From<chalk_ir::ClosureId<Interner>> for crate::db::ClosureId { | 718 | impl From<chalk_ir::ClosureId<Interner>> for crate::db::InternedClosureId { |
715 | fn from(id: chalk_ir::ClosureId<Interner>) -> Self { | 719 | fn from(id: chalk_ir::ClosureId<Interner>) -> Self { |
716 | Self::from_intern_id(id.0) | 720 | Self::from_intern_id(id.0) |
717 | } | 721 | } |
718 | } | 722 | } |
719 | 723 | ||
720 | impl From<crate::db::ClosureId> for chalk_ir::ClosureId<Interner> { | 724 | impl From<crate::db::InternedClosureId> for chalk_ir::ClosureId<Interner> { |
721 | fn from(id: crate::db::ClosureId) -> Self { | 725 | fn from(id: crate::db::InternedClosureId) -> Self { |
722 | chalk_ir::ClosureId(id.as_intern_id()) | 726 | chalk_ir::ClosureId(id.as_intern_id()) |
723 | } | 727 | } |
724 | } | 728 | } |
diff --git a/crates/hir_ty/src/traits/chalk/interner.rs b/crates/hir_ty/src/traits/chalk/interner.rs index 54bd1c724..1dc3f497d 100644 --- a/crates/hir_ty/src/traits/chalk/interner.rs +++ b/crates/hir_ty/src/traits/chalk/interner.rs | |||
@@ -12,7 +12,6 @@ pub struct Interner; | |||
12 | 12 | ||
13 | pub(crate) type AssocTypeId = chalk_ir::AssocTypeId<Interner>; | 13 | pub(crate) type AssocTypeId = chalk_ir::AssocTypeId<Interner>; |
14 | pub(crate) type AssociatedTyDatum = chalk_solve::rust_ir::AssociatedTyDatum<Interner>; | 14 | pub(crate) type AssociatedTyDatum = chalk_solve::rust_ir::AssociatedTyDatum<Interner>; |
15 | pub(crate) type ForeignDefId = chalk_ir::ForeignDefId<Interner>; | ||
16 | pub(crate) type TraitId = chalk_ir::TraitId<Interner>; | 15 | pub(crate) type TraitId = chalk_ir::TraitId<Interner>; |
17 | pub(crate) type TraitDatum = chalk_solve::rust_ir::TraitDatum<Interner>; | 16 | pub(crate) type TraitDatum = chalk_solve::rust_ir::TraitDatum<Interner>; |
18 | pub(crate) type AdtId = chalk_ir::AdtId<Interner>; | 17 | pub(crate) type AdtId = chalk_ir::AdtId<Interner>; |
@@ -21,7 +20,6 @@ pub(crate) type ImplId = chalk_ir::ImplId<Interner>; | |||
21 | pub(crate) type ImplDatum = chalk_solve::rust_ir::ImplDatum<Interner>; | 20 | pub(crate) type ImplDatum = chalk_solve::rust_ir::ImplDatum<Interner>; |
22 | pub(crate) type AssociatedTyValueId = chalk_solve::rust_ir::AssociatedTyValueId<Interner>; | 21 | pub(crate) type AssociatedTyValueId = chalk_solve::rust_ir::AssociatedTyValueId<Interner>; |
23 | pub(crate) type AssociatedTyValue = chalk_solve::rust_ir::AssociatedTyValue<Interner>; | 22 | pub(crate) type AssociatedTyValue = chalk_solve::rust_ir::AssociatedTyValue<Interner>; |
24 | pub(crate) type FnDefId = chalk_ir::FnDefId<Interner>; | ||
25 | pub(crate) type FnDefDatum = chalk_solve::rust_ir::FnDefDatum<Interner>; | 23 | pub(crate) type FnDefDatum = chalk_solve::rust_ir::FnDefDatum<Interner>; |
26 | pub(crate) type OpaqueTyId = chalk_ir::OpaqueTyId<Interner>; | 24 | pub(crate) type OpaqueTyId = chalk_ir::OpaqueTyId<Interner>; |
27 | pub(crate) type OpaqueTyDatum = chalk_solve::rust_ir::OpaqueTyDatum<Interner>; | 25 | pub(crate) type OpaqueTyDatum = chalk_solve::rust_ir::OpaqueTyDatum<Interner>; |
diff --git a/crates/hir_ty/src/traits/chalk/mapping.rs b/crates/hir_ty/src/traits/chalk/mapping.rs index b0415e8b0..2a66a2310 100644 --- a/crates/hir_ty/src/traits/chalk/mapping.rs +++ b/crates/hir_ty/src/traits/chalk/mapping.rs | |||
@@ -3,10 +3,7 @@ | |||
3 | //! Chalk (in both directions); plus some helper functions for more specialized | 3 | //! Chalk (in both directions); plus some helper functions for more specialized |
4 | //! conversions. | 4 | //! conversions. |
5 | 5 | ||
6 | use chalk_ir::{ | 6 | use chalk_ir::{cast::Cast, fold::shift::Shift, interner::HasInterner, LifetimeData}; |
7 | cast::Cast, fold::shift::Shift, interner::HasInterner, LifetimeData, PlaceholderIndex, | ||
8 | UniverseIndex, | ||
9 | }; | ||
10 | use chalk_solve::rust_ir; | 7 | use chalk_solve::rust_ir; |
11 | 8 | ||
12 | use base_db::salsa::InternKey; | 9 | use base_db::salsa::InternKey; |
@@ -14,10 +11,11 @@ use hir_def::{AssocContainerId, GenericDefId, Lookup, TypeAliasId}; | |||
14 | 11 | ||
15 | use crate::{ | 12 | use crate::{ |
16 | db::HirDatabase, | 13 | db::HirDatabase, |
14 | from_assoc_type_id, | ||
17 | primitive::UintTy, | 15 | primitive::UintTy, |
18 | traits::{Canonical, Obligation}, | 16 | traits::{Canonical, Obligation}, |
19 | AliasTy, CallableDefId, FnPointer, FnSig, GenericPredicate, InEnvironment, OpaqueTy, | 17 | AliasTy, CallableDefId, FnPointer, FnSig, GenericPredicate, InEnvironment, OpaqueTy, |
20 | OpaqueTyId, ProjectionPredicate, ProjectionTy, Scalar, Substs, TraitRef, Ty, | 18 | ProjectionPredicate, ProjectionTy, Scalar, Substs, TraitRef, Ty, |
21 | }; | 19 | }; |
22 | 20 | ||
23 | use super::interner::*; | 21 | use super::interner::*; |
@@ -26,10 +24,10 @@ use super::*; | |||
26 | impl ToChalk for Ty { | 24 | impl ToChalk for Ty { |
27 | type Chalk = chalk_ir::Ty<Interner>; | 25 | type Chalk = chalk_ir::Ty<Interner>; |
28 | fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::Ty<Interner> { | 26 | fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::Ty<Interner> { |
29 | match self { | 27 | match self.0 { |
30 | Ty::Ref(m, parameters) => ref_to_chalk(db, m, parameters), | 28 | TyKind::Ref(m, parameters) => ref_to_chalk(db, m, parameters), |
31 | Ty::Array(parameters) => array_to_chalk(db, parameters), | 29 | TyKind::Array(parameters) => array_to_chalk(db, parameters), |
32 | Ty::Function(FnPointer { sig: FnSig { variadic }, substs, .. }) => { | 30 | TyKind::Function(FnPointer { sig: FnSig { variadic }, substs, .. }) => { |
33 | let substitution = chalk_ir::FnSubst(substs.to_chalk(db).shifted_in(&Interner)); | 31 | let substitution = chalk_ir::FnSubst(substs.to_chalk(db).shifted_in(&Interner)); |
34 | chalk_ir::TyKind::Function(chalk_ir::FnPointer { | 32 | chalk_ir::TyKind::Function(chalk_ir::FnPointer { |
35 | num_binders: 0, | 33 | num_binders: 0, |
@@ -38,58 +36,49 @@ impl ToChalk for Ty { | |||
38 | }) | 36 | }) |
39 | .intern(&Interner) | 37 | .intern(&Interner) |
40 | } | 38 | } |
41 | Ty::AssociatedType(type_alias, substs) => { | 39 | TyKind::AssociatedType(assoc_type_id, substs) => { |
42 | let assoc_type = TypeAliasAsAssocType(type_alias); | ||
43 | let assoc_type_id = assoc_type.to_chalk(db); | ||
44 | let substitution = substs.to_chalk(db); | 40 | let substitution = substs.to_chalk(db); |
45 | chalk_ir::TyKind::AssociatedType(assoc_type_id, substitution).intern(&Interner) | 41 | chalk_ir::TyKind::AssociatedType(assoc_type_id, substitution).intern(&Interner) |
46 | } | 42 | } |
47 | 43 | ||
48 | Ty::OpaqueType(impl_trait_id, substs) => { | 44 | TyKind::OpaqueType(id, substs) => { |
49 | let id = impl_trait_id.to_chalk(db); | ||
50 | let substitution = substs.to_chalk(db); | 45 | let substitution = substs.to_chalk(db); |
51 | chalk_ir::TyKind::OpaqueType(id, substitution).intern(&Interner) | 46 | chalk_ir::TyKind::OpaqueType(id, substitution).intern(&Interner) |
52 | } | 47 | } |
53 | 48 | ||
54 | Ty::ForeignType(type_alias) => { | 49 | TyKind::ForeignType(id) => chalk_ir::TyKind::Foreign(id).intern(&Interner), |
55 | let foreign_type = TypeAliasAsForeignType(type_alias); | ||
56 | let foreign_type_id = foreign_type.to_chalk(db); | ||
57 | chalk_ir::TyKind::Foreign(foreign_type_id).intern(&Interner) | ||
58 | } | ||
59 | 50 | ||
60 | Ty::Scalar(scalar) => chalk_ir::TyKind::Scalar(scalar).intern(&Interner), | 51 | TyKind::Scalar(scalar) => chalk_ir::TyKind::Scalar(scalar).intern(&Interner), |
61 | 52 | ||
62 | Ty::Tuple(cardinality, substs) => { | 53 | TyKind::Tuple(cardinality, substs) => { |
63 | let substitution = substs.to_chalk(db); | 54 | let substitution = substs.to_chalk(db); |
64 | chalk_ir::TyKind::Tuple(cardinality.into(), substitution).intern(&Interner) | 55 | chalk_ir::TyKind::Tuple(cardinality.into(), substitution).intern(&Interner) |
65 | } | 56 | } |
66 | Ty::Raw(mutability, substs) => { | 57 | TyKind::Raw(mutability, substs) => { |
67 | let ty = substs[0].clone().to_chalk(db); | 58 | let ty = substs[0].clone().to_chalk(db); |
68 | chalk_ir::TyKind::Raw(mutability, ty).intern(&Interner) | 59 | chalk_ir::TyKind::Raw(mutability, ty).intern(&Interner) |
69 | } | 60 | } |
70 | Ty::Slice(substs) => { | 61 | TyKind::Slice(substs) => { |
71 | chalk_ir::TyKind::Slice(substs[0].clone().to_chalk(db)).intern(&Interner) | 62 | chalk_ir::TyKind::Slice(substs[0].clone().to_chalk(db)).intern(&Interner) |
72 | } | 63 | } |
73 | Ty::Str => chalk_ir::TyKind::Str.intern(&Interner), | 64 | TyKind::Str => chalk_ir::TyKind::Str.intern(&Interner), |
74 | Ty::FnDef(callable_def, substs) => { | 65 | TyKind::FnDef(id, substs) => { |
75 | let id = callable_def.to_chalk(db); | ||
76 | let substitution = substs.to_chalk(db); | 66 | let substitution = substs.to_chalk(db); |
77 | chalk_ir::TyKind::FnDef(id, substitution).intern(&Interner) | 67 | chalk_ir::TyKind::FnDef(id, substitution).intern(&Interner) |
78 | } | 68 | } |
79 | Ty::Never => chalk_ir::TyKind::Never.intern(&Interner), | 69 | TyKind::Never => chalk_ir::TyKind::Never.intern(&Interner), |
80 | 70 | ||
81 | Ty::Closure(def, expr, substs) => { | 71 | TyKind::Closure(closure_id, substs) => { |
82 | let closure_id = db.intern_closure((def, expr)); | ||
83 | let substitution = substs.to_chalk(db); | 72 | let substitution = substs.to_chalk(db); |
84 | chalk_ir::TyKind::Closure(closure_id.into(), substitution).intern(&Interner) | 73 | chalk_ir::TyKind::Closure(closure_id, substitution).intern(&Interner) |
85 | } | 74 | } |
86 | 75 | ||
87 | Ty::Adt(adt_id, substs) => { | 76 | TyKind::Adt(adt_id, substs) => { |
88 | let substitution = substs.to_chalk(db); | 77 | let substitution = substs.to_chalk(db); |
89 | chalk_ir::TyKind::Adt(adt_id, substitution).intern(&Interner) | 78 | chalk_ir::TyKind::Adt(adt_id, substitution).intern(&Interner) |
90 | } | 79 | } |
91 | Ty::Alias(AliasTy::Projection(proj_ty)) => { | 80 | TyKind::Alias(AliasTy::Projection(proj_ty)) => { |
92 | let associated_ty_id = TypeAliasAsAssocType(proj_ty.associated_ty).to_chalk(db); | 81 | let associated_ty_id = proj_ty.associated_ty; |
93 | let substitution = proj_ty.parameters.to_chalk(db); | 82 | let substitution = proj_ty.parameters.to_chalk(db); |
94 | chalk_ir::AliasTy::Projection(chalk_ir::ProjectionTy { | 83 | chalk_ir::AliasTy::Projection(chalk_ir::ProjectionTy { |
95 | associated_ty_id, | 84 | associated_ty_id, |
@@ -98,17 +87,10 @@ impl ToChalk for Ty { | |||
98 | .cast(&Interner) | 87 | .cast(&Interner) |
99 | .intern(&Interner) | 88 | .intern(&Interner) |
100 | } | 89 | } |
101 | Ty::Placeholder(id) => { | 90 | TyKind::Placeholder(idx) => idx.to_ty::<Interner>(&Interner), |
102 | let interned_id = db.intern_type_param_id(id); | 91 | TyKind::BoundVar(idx) => chalk_ir::TyKind::BoundVar(idx).intern(&Interner), |
103 | PlaceholderIndex { | 92 | TyKind::InferenceVar(..) => panic!("uncanonicalized infer ty"), |
104 | ui: UniverseIndex::ROOT, | 93 | TyKind::Dyn(predicates) => { |
105 | idx: interned_id.as_intern_id().as_usize(), | ||
106 | } | ||
107 | .to_ty::<Interner>(&Interner) | ||
108 | } | ||
109 | Ty::BoundVar(idx) => chalk_ir::TyKind::BoundVar(idx).intern(&Interner), | ||
110 | Ty::InferenceVar(..) => panic!("uncanonicalized infer ty"), | ||
111 | Ty::Dyn(predicates) => { | ||
112 | let where_clauses = chalk_ir::QuantifiedWhereClauses::from_iter( | 94 | let where_clauses = chalk_ir::QuantifiedWhereClauses::from_iter( |
113 | &Interner, | 95 | &Interner, |
114 | predicates.iter().filter(|p| !p.is_error()).cloned().map(|p| p.to_chalk(db)), | 96 | predicates.iter().filter(|p| !p.is_error()).cloned().map(|p| p.to_chalk(db)), |
@@ -119,8 +101,8 @@ impl ToChalk for Ty { | |||
119 | }; | 101 | }; |
120 | chalk_ir::TyKind::Dyn(bounded_ty).intern(&Interner) | 102 | chalk_ir::TyKind::Dyn(bounded_ty).intern(&Interner) |
121 | } | 103 | } |
122 | Ty::Alias(AliasTy::Opaque(opaque_ty)) => { | 104 | TyKind::Alias(AliasTy::Opaque(opaque_ty)) => { |
123 | let opaque_ty_id = opaque_ty.opaque_ty_id.to_chalk(db); | 105 | let opaque_ty_id = opaque_ty.opaque_ty_id; |
124 | let substitution = opaque_ty.parameters.to_chalk(db); | 106 | let substitution = opaque_ty.parameters.to_chalk(db); |
125 | chalk_ir::TyKind::Alias(chalk_ir::AliasTy::Opaque(chalk_ir::OpaqueTy { | 107 | chalk_ir::TyKind::Alias(chalk_ir::AliasTy::Opaque(chalk_ir::OpaqueTy { |
126 | opaque_ty_id, | 108 | opaque_ty_id, |
@@ -128,30 +110,23 @@ impl ToChalk for Ty { | |||
128 | })) | 110 | })) |
129 | .intern(&Interner) | 111 | .intern(&Interner) |
130 | } | 112 | } |
131 | Ty::Unknown => chalk_ir::TyKind::Error.intern(&Interner), | 113 | TyKind::Unknown => chalk_ir::TyKind::Error.intern(&Interner), |
132 | } | 114 | } |
133 | } | 115 | } |
134 | fn from_chalk(db: &dyn HirDatabase, chalk: chalk_ir::Ty<Interner>) -> Self { | 116 | fn from_chalk(db: &dyn HirDatabase, chalk: chalk_ir::Ty<Interner>) -> Self { |
135 | match chalk.data(&Interner).kind.clone() { | 117 | match chalk.data(&Interner).kind.clone() { |
136 | chalk_ir::TyKind::Error => Ty::Unknown, | 118 | chalk_ir::TyKind::Error => TyKind::Unknown, |
137 | chalk_ir::TyKind::Array(ty, _size) => Ty::Array(Substs::single(from_chalk(db, ty))), | 119 | chalk_ir::TyKind::Array(ty, _size) => TyKind::Array(Substs::single(from_chalk(db, ty))), |
138 | chalk_ir::TyKind::Placeholder(idx) => { | 120 | chalk_ir::TyKind::Placeholder(idx) => TyKind::Placeholder(idx), |
139 | assert_eq!(idx.ui, UniverseIndex::ROOT); | ||
140 | let interned_id = crate::db::GlobalTypeParamId::from_intern_id( | ||
141 | crate::salsa::InternId::from(idx.idx), | ||
142 | ); | ||
143 | Ty::Placeholder(db.lookup_intern_type_param_id(interned_id)) | ||
144 | } | ||
145 | chalk_ir::TyKind::Alias(chalk_ir::AliasTy::Projection(proj)) => { | 121 | chalk_ir::TyKind::Alias(chalk_ir::AliasTy::Projection(proj)) => { |
146 | let associated_ty = | 122 | let associated_ty = proj.associated_ty_id; |
147 | from_chalk::<TypeAliasAsAssocType, _>(db, proj.associated_ty_id).0; | ||
148 | let parameters = from_chalk(db, proj.substitution); | 123 | let parameters = from_chalk(db, proj.substitution); |
149 | Ty::Alias(AliasTy::Projection(ProjectionTy { associated_ty, parameters })) | 124 | TyKind::Alias(AliasTy::Projection(ProjectionTy { associated_ty, parameters })) |
150 | } | 125 | } |
151 | chalk_ir::TyKind::Alias(chalk_ir::AliasTy::Opaque(opaque_ty)) => { | 126 | chalk_ir::TyKind::Alias(chalk_ir::AliasTy::Opaque(opaque_ty)) => { |
152 | let impl_trait_id = from_chalk(db, opaque_ty.opaque_ty_id); | 127 | let opaque_ty_id = opaque_ty.opaque_ty_id; |
153 | let parameters = from_chalk(db, opaque_ty.substitution); | 128 | let parameters = from_chalk(db, opaque_ty.substitution); |
154 | Ty::Alias(AliasTy::Opaque(OpaqueTy { opaque_ty_id: impl_trait_id, parameters })) | 129 | TyKind::Alias(AliasTy::Opaque(OpaqueTy { opaque_ty_id, parameters })) |
155 | } | 130 | } |
156 | chalk_ir::TyKind::Function(chalk_ir::FnPointer { | 131 | chalk_ir::TyKind::Function(chalk_ir::FnPointer { |
157 | num_binders, | 132 | num_binders, |
@@ -164,14 +139,14 @@ impl ToChalk for Ty { | |||
164 | db, | 139 | db, |
165 | substitution.0.shifted_out(&Interner).expect("fn ptr should have no binders"), | 140 | substitution.0.shifted_out(&Interner).expect("fn ptr should have no binders"), |
166 | ); | 141 | ); |
167 | Ty::Function(FnPointer { | 142 | TyKind::Function(FnPointer { |
168 | num_args: (substs.len() - 1), | 143 | num_args: (substs.len() - 1), |
169 | sig: FnSig { variadic }, | 144 | sig: FnSig { variadic }, |
170 | substs, | 145 | substs, |
171 | }) | 146 | }) |
172 | } | 147 | } |
173 | chalk_ir::TyKind::BoundVar(idx) => Ty::BoundVar(idx), | 148 | chalk_ir::TyKind::BoundVar(idx) => TyKind::BoundVar(idx), |
174 | chalk_ir::TyKind::InferenceVar(_iv, _kind) => Ty::Unknown, | 149 | chalk_ir::TyKind::InferenceVar(_iv, _kind) => TyKind::Unknown, |
175 | chalk_ir::TyKind::Dyn(where_clauses) => { | 150 | chalk_ir::TyKind::Dyn(where_clauses) => { |
176 | assert_eq!(where_clauses.bounds.binders.len(&Interner), 1); | 151 | assert_eq!(where_clauses.bounds.binders.len(&Interner), 1); |
177 | let predicates = where_clauses | 152 | let predicates = where_clauses |
@@ -180,49 +155,43 @@ impl ToChalk for Ty { | |||
180 | .iter(&Interner) | 155 | .iter(&Interner) |
181 | .map(|c| from_chalk(db, c.clone())) | 156 | .map(|c| from_chalk(db, c.clone())) |
182 | .collect(); | 157 | .collect(); |
183 | Ty::Dyn(predicates) | 158 | TyKind::Dyn(predicates) |
184 | } | 159 | } |
185 | 160 | ||
186 | chalk_ir::TyKind::Adt(adt_id, subst) => Ty::Adt(adt_id, from_chalk(db, subst)), | 161 | chalk_ir::TyKind::Adt(adt_id, subst) => TyKind::Adt(adt_id, from_chalk(db, subst)), |
187 | chalk_ir::TyKind::AssociatedType(type_id, subst) => Ty::AssociatedType( | 162 | chalk_ir::TyKind::AssociatedType(type_id, subst) => { |
188 | from_chalk::<TypeAliasAsAssocType, _>(db, type_id).0, | 163 | TyKind::AssociatedType(type_id, from_chalk(db, subst)) |
189 | from_chalk(db, subst), | 164 | } |
190 | ), | ||
191 | 165 | ||
192 | chalk_ir::TyKind::OpaqueType(opaque_type_id, subst) => { | 166 | chalk_ir::TyKind::OpaqueType(opaque_type_id, subst) => { |
193 | Ty::OpaqueType(from_chalk(db, opaque_type_id), from_chalk(db, subst)) | 167 | TyKind::OpaqueType(opaque_type_id, from_chalk(db, subst)) |
194 | } | 168 | } |
195 | 169 | ||
196 | chalk_ir::TyKind::Scalar(scalar) => Ty::Scalar(scalar), | 170 | chalk_ir::TyKind::Scalar(scalar) => TyKind::Scalar(scalar), |
197 | chalk_ir::TyKind::Tuple(cardinality, subst) => { | 171 | chalk_ir::TyKind::Tuple(cardinality, subst) => { |
198 | Ty::Tuple(cardinality, from_chalk(db, subst)) | 172 | TyKind::Tuple(cardinality, from_chalk(db, subst)) |
199 | } | 173 | } |
200 | chalk_ir::TyKind::Raw(mutability, ty) => { | 174 | chalk_ir::TyKind::Raw(mutability, ty) => { |
201 | Ty::Raw(mutability, Substs::single(from_chalk(db, ty))) | 175 | TyKind::Raw(mutability, Substs::single(from_chalk(db, ty))) |
202 | } | 176 | } |
203 | chalk_ir::TyKind::Slice(ty) => Ty::Slice(Substs::single(from_chalk(db, ty))), | 177 | chalk_ir::TyKind::Slice(ty) => TyKind::Slice(Substs::single(from_chalk(db, ty))), |
204 | chalk_ir::TyKind::Ref(mutability, _lifetime, ty) => { | 178 | chalk_ir::TyKind::Ref(mutability, _lifetime, ty) => { |
205 | Ty::Ref(mutability, Substs::single(from_chalk(db, ty))) | 179 | TyKind::Ref(mutability, Substs::single(from_chalk(db, ty))) |
206 | } | 180 | } |
207 | chalk_ir::TyKind::Str => Ty::Str, | 181 | chalk_ir::TyKind::Str => TyKind::Str, |
208 | chalk_ir::TyKind::Never => Ty::Never, | 182 | chalk_ir::TyKind::Never => TyKind::Never, |
209 | 183 | ||
210 | chalk_ir::TyKind::FnDef(fn_def_id, subst) => { | 184 | chalk_ir::TyKind::FnDef(fn_def_id, subst) => { |
211 | Ty::FnDef(from_chalk(db, fn_def_id), from_chalk(db, subst)) | 185 | TyKind::FnDef(fn_def_id, from_chalk(db, subst)) |
212 | } | 186 | } |
213 | 187 | ||
214 | chalk_ir::TyKind::Closure(id, subst) => { | 188 | chalk_ir::TyKind::Closure(id, subst) => TyKind::Closure(id, from_chalk(db, subst)), |
215 | let id: crate::db::ClosureId = id.into(); | ||
216 | let (def, expr) = db.lookup_intern_closure(id); | ||
217 | Ty::Closure(def, expr, from_chalk(db, subst)) | ||
218 | } | ||
219 | 189 | ||
220 | chalk_ir::TyKind::Foreign(foreign_def_id) => { | 190 | chalk_ir::TyKind::Foreign(foreign_def_id) => TyKind::ForeignType(foreign_def_id), |
221 | Ty::ForeignType(from_chalk::<TypeAliasAsForeignType, _>(db, foreign_def_id).0) | ||
222 | } | ||
223 | chalk_ir::TyKind::Generator(_, _) => unimplemented!(), // FIXME | 191 | chalk_ir::TyKind::Generator(_, _) => unimplemented!(), // FIXME |
224 | chalk_ir::TyKind::GeneratorWitness(_, _) => unimplemented!(), // FIXME | 192 | chalk_ir::TyKind::GeneratorWitness(_, _) => unimplemented!(), // FIXME |
225 | } | 193 | } |
194 | .intern(&Interner) | ||
226 | } | 195 | } |
227 | } | 196 | } |
228 | 197 | ||
@@ -298,21 +267,6 @@ impl ToChalk for hir_def::TraitId { | |||
298 | } | 267 | } |
299 | } | 268 | } |
300 | 269 | ||
301 | impl ToChalk for OpaqueTyId { | ||
302 | type Chalk = chalk_ir::OpaqueTyId<Interner>; | ||
303 | |||
304 | fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::OpaqueTyId<Interner> { | ||
305 | db.intern_impl_trait_id(self).into() | ||
306 | } | ||
307 | |||
308 | fn from_chalk( | ||
309 | db: &dyn HirDatabase, | ||
310 | opaque_ty_id: chalk_ir::OpaqueTyId<Interner>, | ||
311 | ) -> OpaqueTyId { | ||
312 | db.lookup_intern_impl_trait_id(opaque_ty_id.into()) | ||
313 | } | ||
314 | } | ||
315 | |||
316 | impl ToChalk for hir_def::ImplId { | 270 | impl ToChalk for hir_def::ImplId { |
317 | type Chalk = ImplId; | 271 | type Chalk = ImplId; |
318 | 272 | ||
@@ -337,34 +291,6 @@ impl ToChalk for CallableDefId { | |||
337 | } | 291 | } |
338 | } | 292 | } |
339 | 293 | ||
340 | pub(crate) struct TypeAliasAsAssocType(pub(crate) TypeAliasId); | ||
341 | |||
342 | impl ToChalk for TypeAliasAsAssocType { | ||
343 | type Chalk = AssocTypeId; | ||
344 | |||
345 | fn to_chalk(self, _db: &dyn HirDatabase) -> AssocTypeId { | ||
346 | chalk_ir::AssocTypeId(self.0.as_intern_id()) | ||
347 | } | ||
348 | |||
349 | fn from_chalk(_db: &dyn HirDatabase, assoc_type_id: AssocTypeId) -> TypeAliasAsAssocType { | ||
350 | TypeAliasAsAssocType(InternKey::from_intern_id(assoc_type_id.0)) | ||
351 | } | ||
352 | } | ||
353 | |||
354 | pub(crate) struct TypeAliasAsForeignType(pub(crate) TypeAliasId); | ||
355 | |||
356 | impl ToChalk for TypeAliasAsForeignType { | ||
357 | type Chalk = ForeignDefId; | ||
358 | |||
359 | fn to_chalk(self, _db: &dyn HirDatabase) -> ForeignDefId { | ||
360 | chalk_ir::ForeignDefId(self.0.as_intern_id()) | ||
361 | } | ||
362 | |||
363 | fn from_chalk(_db: &dyn HirDatabase, foreign_def_id: ForeignDefId) -> TypeAliasAsForeignType { | ||
364 | TypeAliasAsForeignType(InternKey::from_intern_id(foreign_def_id.0)) | ||
365 | } | ||
366 | } | ||
367 | |||
368 | pub(crate) struct TypeAliasAsValue(pub(crate) TypeAliasId); | 294 | pub(crate) struct TypeAliasAsValue(pub(crate) TypeAliasId); |
369 | 295 | ||
370 | impl ToChalk for TypeAliasAsValue { | 296 | impl ToChalk for TypeAliasAsValue { |
@@ -446,7 +372,7 @@ impl ToChalk for ProjectionTy { | |||
446 | 372 | ||
447 | fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::ProjectionTy<Interner> { | 373 | fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::ProjectionTy<Interner> { |
448 | chalk_ir::ProjectionTy { | 374 | chalk_ir::ProjectionTy { |
449 | associated_ty_id: TypeAliasAsAssocType(self.associated_ty).to_chalk(db), | 375 | associated_ty_id: self.associated_ty, |
450 | substitution: self.parameters.to_chalk(db), | 376 | substitution: self.parameters.to_chalk(db), |
451 | } | 377 | } |
452 | } | 378 | } |
@@ -456,11 +382,7 @@ impl ToChalk for ProjectionTy { | |||
456 | projection_ty: chalk_ir::ProjectionTy<Interner>, | 382 | projection_ty: chalk_ir::ProjectionTy<Interner>, |
457 | ) -> ProjectionTy { | 383 | ) -> ProjectionTy { |
458 | ProjectionTy { | 384 | ProjectionTy { |
459 | associated_ty: from_chalk::<TypeAliasAsAssocType, _>( | 385 | associated_ty: projection_ty.associated_ty_id, |
460 | db, | ||
461 | projection_ty.associated_ty_id, | ||
462 | ) | ||
463 | .0, | ||
464 | parameters: from_chalk(db, projection_ty.substitution), | 386 | parameters: from_chalk(db, projection_ty.substitution), |
465 | } | 387 | } |
466 | } | 388 | } |
@@ -614,7 +536,10 @@ pub(super) fn generic_predicate_to_inline_bound( | |||
614 | if &proj.projection_ty.parameters[0] != self_ty { | 536 | if &proj.projection_ty.parameters[0] != self_ty { |
615 | return None; | 537 | return None; |
616 | } | 538 | } |
617 | let trait_ = match proj.projection_ty.associated_ty.lookup(db.upcast()).container { | 539 | let trait_ = match from_assoc_type_id(proj.projection_ty.associated_ty) |
540 | .lookup(db.upcast()) | ||
541 | .container | ||
542 | { | ||
618 | AssocContainerId::TraitId(t) => t, | 543 | AssocContainerId::TraitId(t) => t, |
619 | _ => panic!("associated type not in trait"), | 544 | _ => panic!("associated type not in trait"), |
620 | }; | 545 | }; |
@@ -625,8 +550,7 @@ pub(super) fn generic_predicate_to_inline_bound( | |||
625 | let alias_eq_bound = rust_ir::AliasEqBound { | 550 | let alias_eq_bound = rust_ir::AliasEqBound { |
626 | value: proj.ty.clone().to_chalk(db), | 551 | value: proj.ty.clone().to_chalk(db), |
627 | trait_bound: rust_ir::TraitBound { trait_id: trait_.to_chalk(db), args_no_self }, | 552 | trait_bound: rust_ir::TraitBound { trait_id: trait_.to_chalk(db), args_no_self }, |
628 | associated_ty_id: TypeAliasAsAssocType(proj.projection_ty.associated_ty) | 553 | associated_ty_id: proj.projection_ty.associated_ty, |
629 | .to_chalk(db), | ||
630 | parameters: Vec::new(), // FIXME we don't support generic associated types yet | 554 | parameters: Vec::new(), // FIXME we don't support generic associated types yet |
631 | }; | 555 | }; |
632 | Some(rust_ir::InlineBound::AliasEqBound(alias_eq_bound)) | 556 | Some(rust_ir::InlineBound::AliasEqBound(alias_eq_bound)) |
diff --git a/crates/hir_ty/src/traits/chalk/tls.rs b/crates/hir_ty/src/traits/chalk/tls.rs index 75b16172e..8892a63a9 100644 --- a/crates/hir_ty/src/traits/chalk/tls.rs +++ b/crates/hir_ty/src/traits/chalk/tls.rs | |||
@@ -4,8 +4,8 @@ use std::fmt; | |||
4 | use chalk_ir::{AliasTy, GenericArg, Goal, Goals, Lifetime, ProgramClauseImplication}; | 4 | use chalk_ir::{AliasTy, GenericArg, Goal, Goals, Lifetime, ProgramClauseImplication}; |
5 | use itertools::Itertools; | 5 | use itertools::Itertools; |
6 | 6 | ||
7 | use super::{from_chalk, Interner, TypeAliasAsAssocType}; | 7 | use super::{from_chalk, Interner}; |
8 | use crate::{db::HirDatabase, CallableDefId}; | 8 | use crate::{db::HirDatabase, from_assoc_type_id, CallableDefId}; |
9 | use hir_def::{AdtId, AssocContainerId, Lookup, TypeAliasId}; | 9 | use hir_def::{AdtId, AssocContainerId, Lookup, TypeAliasId}; |
10 | 10 | ||
11 | pub(crate) use unsafe_tls::{set_current_program, with_current_program}; | 11 | pub(crate) use unsafe_tls::{set_current_program, with_current_program}; |
@@ -41,7 +41,7 @@ impl DebugContext<'_> { | |||
41 | id: super::AssocTypeId, | 41 | id: super::AssocTypeId, |
42 | fmt: &mut fmt::Formatter<'_>, | 42 | fmt: &mut fmt::Formatter<'_>, |
43 | ) -> Result<(), fmt::Error> { | 43 | ) -> Result<(), fmt::Error> { |
44 | let type_alias: TypeAliasId = from_chalk::<TypeAliasAsAssocType, _>(self.0, id).0; | 44 | let type_alias: TypeAliasId = from_assoc_type_id(id); |
45 | let type_alias_data = self.0.type_alias_data(type_alias); | 45 | let type_alias_data = self.0.type_alias_data(type_alias); |
46 | let trait_ = match type_alias.lookup(self.0.upcast()).container { | 46 | let trait_ = match type_alias.lookup(self.0.upcast()).container { |
47 | AssocContainerId::TraitId(t) => t, | 47 | AssocContainerId::TraitId(t) => t, |
@@ -75,8 +75,7 @@ impl DebugContext<'_> { | |||
75 | projection_ty: &chalk_ir::ProjectionTy<Interner>, | 75 | projection_ty: &chalk_ir::ProjectionTy<Interner>, |
76 | fmt: &mut fmt::Formatter<'_>, | 76 | fmt: &mut fmt::Formatter<'_>, |
77 | ) -> Result<(), fmt::Error> { | 77 | ) -> Result<(), fmt::Error> { |
78 | let type_alias: TypeAliasId = | 78 | let type_alias = from_assoc_type_id(projection_ty.associated_ty_id); |
79 | from_chalk::<TypeAliasAsAssocType, _>(self.0, projection_ty.associated_ty_id).0; | ||
80 | let type_alias_data = self.0.type_alias_data(type_alias); | 79 | let type_alias_data = self.0.type_alias_data(type_alias); |
81 | let trait_ = match type_alias.lookup(self.0.upcast()).container { | 80 | let trait_ = match type_alias.lookup(self.0.upcast()).container { |
82 | AssocContainerId::TraitId(t) => t, | 81 | AssocContainerId::TraitId(t) => t, |