diff options
Diffstat (limited to 'crates/ra_hir/src/ty/lower.rs')
-rw-r--r-- | crates/ra_hir/src/ty/lower.rs | 83 |
1 files changed, 45 insertions, 38 deletions
diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs index 397ee7d5f..75c552569 100644 --- a/crates/ra_hir/src/ty/lower.rs +++ b/crates/ra_hir/src/ty/lower.rs | |||
@@ -10,8 +10,11 @@ use std::sync::Arc; | |||
10 | 10 | ||
11 | use hir_def::{ | 11 | use hir_def::{ |
12 | builtin_type::{BuiltinFloat, BuiltinInt, BuiltinType}, | 12 | builtin_type::{BuiltinFloat, BuiltinInt, BuiltinType}, |
13 | generics::WherePredicate, | ||
13 | path::{GenericArg, PathSegment}, | 14 | path::{GenericArg, PathSegment}, |
15 | resolver::{HasResolver, Resolver, TypeNs}, | ||
14 | type_ref::{TypeBound, TypeRef}, | 16 | type_ref::{TypeBound, TypeRef}, |
17 | AdtId, GenericDefId, | ||
15 | }; | 18 | }; |
16 | 19 | ||
17 | use super::{ | 20 | use super::{ |
@@ -20,16 +23,13 @@ use super::{ | |||
20 | }; | 23 | }; |
21 | use crate::{ | 24 | use crate::{ |
22 | db::HirDatabase, | 25 | db::HirDatabase, |
23 | generics::HasGenericParams, | ||
24 | generics::{GenericDef, WherePredicate}, | ||
25 | resolve::{HasResolver, Resolver, TypeNs}, | ||
26 | ty::{ | 26 | ty::{ |
27 | primitive::{FloatTy, IntTy, Uncertain}, | 27 | primitive::{FloatTy, IntTy, Uncertain}, |
28 | Adt, | 28 | Adt, |
29 | }, | 29 | }, |
30 | util::make_mut_slice, | 30 | util::make_mut_slice, |
31 | Const, Enum, EnumVariant, Function, ModuleDef, Path, Static, Struct, StructField, Trait, | 31 | Const, Enum, EnumVariant, Function, GenericDef, ImplBlock, ModuleDef, Path, Static, Struct, |
32 | TypeAlias, Union, VariantDef, | 32 | StructField, Trait, TypeAlias, Union, VariantDef, |
33 | }; | 33 | }; |
34 | 34 | ||
35 | // FIXME: this is only really used in `type_for_def`, which contains a bunch of | 35 | // FIXME: this is only really used in `type_for_def`, which contains a bunch of |
@@ -156,9 +156,14 @@ impl Ty { | |||
156 | remaining_segments: &[PathSegment], | 156 | remaining_segments: &[PathSegment], |
157 | ) -> Ty { | 157 | ) -> Ty { |
158 | let ty = match resolution { | 158 | let ty = match resolution { |
159 | TypeNs::Trait(trait_) => { | 159 | TypeNs::TraitId(trait_) => { |
160 | let trait_ref = | 160 | let trait_ref = TraitRef::from_resolved_path( |
161 | TraitRef::from_resolved_path(db, resolver, trait_, resolved_segment, None); | 161 | db, |
162 | resolver, | ||
163 | trait_.into(), | ||
164 | resolved_segment, | ||
165 | None, | ||
166 | ); | ||
162 | return if remaining_segments.len() == 1 { | 167 | return if remaining_segments.len() == 1 { |
163 | let segment = &remaining_segments[0]; | 168 | let segment = &remaining_segments[0]; |
164 | match trait_ref | 169 | match trait_ref |
@@ -189,18 +194,18 @@ impl Ty { | |||
189 | let name = resolved_segment.name.clone(); | 194 | let name = resolved_segment.name.clone(); |
190 | Ty::Param { idx, name } | 195 | Ty::Param { idx, name } |
191 | } | 196 | } |
192 | TypeNs::SelfType(impl_block) => impl_block.target_ty(db), | 197 | TypeNs::SelfType(impl_block) => ImplBlock::from(impl_block).target_ty(db), |
193 | TypeNs::AdtSelfType(adt) => adt.ty(db), | 198 | TypeNs::AdtSelfType(adt) => Adt::from(adt).ty(db), |
194 | 199 | ||
195 | TypeNs::Adt(it) => Ty::from_hir_path_inner(db, resolver, resolved_segment, it.into()), | 200 | TypeNs::AdtId(it) => Ty::from_hir_path_inner(db, resolver, resolved_segment, it.into()), |
196 | TypeNs::BuiltinType(it) => { | 201 | TypeNs::BuiltinType(it) => { |
197 | Ty::from_hir_path_inner(db, resolver, resolved_segment, it.into()) | 202 | Ty::from_hir_path_inner(db, resolver, resolved_segment, it.into()) |
198 | } | 203 | } |
199 | TypeNs::TypeAlias(it) => { | 204 | TypeNs::TypeAliasId(it) => { |
200 | Ty::from_hir_path_inner(db, resolver, resolved_segment, it.into()) | 205 | Ty::from_hir_path_inner(db, resolver, resolved_segment, it.into()) |
201 | } | 206 | } |
202 | // FIXME: report error | 207 | // FIXME: report error |
203 | TypeNs::EnumVariant(_) => return Ty::Unknown, | 208 | TypeNs::EnumVariantId(_) => return Ty::Unknown, |
204 | }; | 209 | }; |
205 | 210 | ||
206 | Ty::from_type_relative_path(db, resolver, ty, remaining_segments) | 211 | Ty::from_type_relative_path(db, resolver, ty, remaining_segments) |
@@ -247,7 +252,7 @@ impl Ty { | |||
247 | Some(def) => def, | 252 | Some(def) => def, |
248 | None => return Ty::Unknown, // this can't actually happen | 253 | None => return Ty::Unknown, // this can't actually happen |
249 | }; | 254 | }; |
250 | let predicates = db.generic_predicates_for_param(def, param_idx); | 255 | let predicates = db.generic_predicates_for_param(def.into(), param_idx); |
251 | let traits_from_env = predicates.iter().filter_map(|pred| match pred { | 256 | let traits_from_env = predicates.iter().filter_map(|pred| match pred { |
252 | GenericPredicate::Implemented(tr) if tr.self_ty() == &self_ty => Some(tr.trait_), | 257 | GenericPredicate::Implemented(tr) if tr.self_ty() == &self_ty => Some(tr.trait_), |
253 | _ => None, | 258 | _ => None, |
@@ -336,7 +341,7 @@ pub(super) fn substs_from_path_segment( | |||
336 | add_self_param: bool, | 341 | add_self_param: bool, |
337 | ) -> Substs { | 342 | ) -> Substs { |
338 | let mut substs = Vec::new(); | 343 | let mut substs = Vec::new(); |
339 | let def_generics = def_generic.map(|def| def.generic_params(db)); | 344 | let def_generics = def_generic.map(|def| db.generic_params(def.into())); |
340 | 345 | ||
341 | let (parent_param_count, param_count) = | 346 | let (parent_param_count, param_count) = |
342 | def_generics.map_or((0, 0), |g| (g.count_parent_params(), g.params.len())); | 347 | def_generics.map_or((0, 0), |g| (g.count_parent_params(), g.params.len())); |
@@ -391,11 +396,11 @@ impl TraitRef { | |||
391 | explicit_self_ty: Option<Ty>, | 396 | explicit_self_ty: Option<Ty>, |
392 | ) -> Option<Self> { | 397 | ) -> Option<Self> { |
393 | let resolved = match resolver.resolve_path_in_type_ns_fully(db, &path)? { | 398 | let resolved = match resolver.resolve_path_in_type_ns_fully(db, &path)? { |
394 | TypeNs::Trait(tr) => tr, | 399 | TypeNs::TraitId(tr) => tr, |
395 | _ => return None, | 400 | _ => return None, |
396 | }; | 401 | }; |
397 | let segment = path.segments.last().expect("path should have at least one segment"); | 402 | let segment = path.segments.last().expect("path should have at least one segment"); |
398 | Some(TraitRef::from_resolved_path(db, resolver, resolved, segment, explicit_self_ty)) | 403 | Some(TraitRef::from_resolved_path(db, resolver, resolved.into(), segment, explicit_self_ty)) |
399 | } | 404 | } |
400 | 405 | ||
401 | pub(super) fn from_resolved_path( | 406 | pub(super) fn from_resolved_path( |
@@ -437,7 +442,7 @@ impl TraitRef { | |||
437 | } | 442 | } |
438 | 443 | ||
439 | pub(crate) fn for_trait(db: &impl HirDatabase, trait_: Trait) -> TraitRef { | 444 | pub(crate) fn for_trait(db: &impl HirDatabase, trait_: Trait) -> TraitRef { |
440 | let substs = Substs::identity(&trait_.generic_params(db)); | 445 | let substs = Substs::identity(&db.generic_params(trait_.id.into())); |
441 | TraitRef { trait_, substs } | 446 | TraitRef { trait_, substs } |
442 | } | 447 | } |
443 | 448 | ||
@@ -548,8 +553,8 @@ pub(crate) fn callable_item_sig(db: &impl HirDatabase, def: CallableDef) -> FnSi | |||
548 | pub(crate) fn type_for_field(db: &impl HirDatabase, field: StructField) -> Ty { | 553 | pub(crate) fn type_for_field(db: &impl HirDatabase, field: StructField) -> Ty { |
549 | let parent_def = field.parent_def(db); | 554 | let parent_def = field.parent_def(db); |
550 | let resolver = match parent_def { | 555 | let resolver = match parent_def { |
551 | VariantDef::Struct(it) => it.resolver(db), | 556 | VariantDef::Struct(it) => it.id.resolver(db), |
552 | VariantDef::EnumVariant(it) => it.parent_enum(db).resolver(db), | 557 | VariantDef::EnumVariant(it) => it.parent.id.resolver(db), |
553 | }; | 558 | }; |
554 | let var_data = parent_def.variant_data(db); | 559 | let var_data = parent_def.variant_data(db); |
555 | let type_ref = &var_data.fields().unwrap()[field.id].type_ref; | 560 | let type_ref = &var_data.fields().unwrap()[field.id].type_ref; |
@@ -569,7 +574,7 @@ pub(crate) fn generic_predicates_for_param_query( | |||
569 | def: GenericDef, | 574 | def: GenericDef, |
570 | param_idx: u32, | 575 | param_idx: u32, |
571 | ) -> Arc<[GenericPredicate]> { | 576 | ) -> Arc<[GenericPredicate]> { |
572 | let resolver = def.resolver(db); | 577 | let resolver = GenericDefId::from(def).resolver(db); |
573 | resolver | 578 | resolver |
574 | .where_predicates_in_scope() | 579 | .where_predicates_in_scope() |
575 | // we have to filter out all other predicates *first*, before attempting to lower them | 580 | // we have to filter out all other predicates *first*, before attempting to lower them |
@@ -595,7 +600,7 @@ pub(crate) fn generic_predicates_query( | |||
595 | db: &impl HirDatabase, | 600 | db: &impl HirDatabase, |
596 | def: GenericDef, | 601 | def: GenericDef, |
597 | ) -> Arc<[GenericPredicate]> { | 602 | ) -> Arc<[GenericPredicate]> { |
598 | let resolver = def.resolver(db); | 603 | let resolver = GenericDefId::from(def).resolver(db); |
599 | resolver | 604 | resolver |
600 | .where_predicates_in_scope() | 605 | .where_predicates_in_scope() |
601 | .flat_map(|pred| GenericPredicate::from_where_predicate(db, &resolver, pred)) | 606 | .flat_map(|pred| GenericPredicate::from_where_predicate(db, &resolver, pred)) |
@@ -604,8 +609,8 @@ pub(crate) fn generic_predicates_query( | |||
604 | 609 | ||
605 | /// Resolve the default type params from generics | 610 | /// Resolve the default type params from generics |
606 | pub(crate) fn generic_defaults_query(db: &impl HirDatabase, def: GenericDef) -> Substs { | 611 | pub(crate) fn generic_defaults_query(db: &impl HirDatabase, def: GenericDef) -> Substs { |
607 | let resolver = def.resolver(db); | 612 | let resolver = GenericDefId::from(def).resolver(db); |
608 | let generic_params = def.generic_params(db); | 613 | let generic_params = db.generic_params(def.into()); |
609 | 614 | ||
610 | let defaults = generic_params | 615 | let defaults = generic_params |
611 | .params_including_parent() | 616 | .params_including_parent() |
@@ -618,7 +623,7 @@ pub(crate) fn generic_defaults_query(db: &impl HirDatabase, def: GenericDef) -> | |||
618 | 623 | ||
619 | fn fn_sig_for_fn(db: &impl HirDatabase, def: Function) -> FnSig { | 624 | fn fn_sig_for_fn(db: &impl HirDatabase, def: Function) -> FnSig { |
620 | let data = def.data(db); | 625 | let data = def.data(db); |
621 | let resolver = def.resolver(db); | 626 | let resolver = def.id.resolver(db); |
622 | let params = data.params().iter().map(|tr| Ty::from_hir(db, &resolver, tr)).collect::<Vec<_>>(); | 627 | let params = data.params().iter().map(|tr| Ty::from_hir(db, &resolver, tr)).collect::<Vec<_>>(); |
623 | let ret = Ty::from_hir(db, &resolver, data.ret_type()); | 628 | let ret = Ty::from_hir(db, &resolver, data.ret_type()); |
624 | FnSig::from_params_and_return(params, ret) | 629 | FnSig::from_params_and_return(params, ret) |
@@ -627,7 +632,7 @@ fn fn_sig_for_fn(db: &impl HirDatabase, def: Function) -> FnSig { | |||
627 | /// Build the declared type of a function. This should not need to look at the | 632 | /// Build the declared type of a function. This should not need to look at the |
628 | /// function body. | 633 | /// function body. |
629 | fn type_for_fn(db: &impl HirDatabase, def: Function) -> Ty { | 634 | fn type_for_fn(db: &impl HirDatabase, def: Function) -> Ty { |
630 | let generics = def.generic_params(db); | 635 | let generics = db.generic_params(def.id.into()); |
631 | let substs = Substs::identity(&generics); | 636 | let substs = Substs::identity(&generics); |
632 | Ty::apply(TypeCtor::FnDef(def.into()), substs) | 637 | Ty::apply(TypeCtor::FnDef(def.into()), substs) |
633 | } | 638 | } |
@@ -635,7 +640,7 @@ fn type_for_fn(db: &impl HirDatabase, def: Function) -> Ty { | |||
635 | /// Build the declared type of a const. | 640 | /// Build the declared type of a const. |
636 | fn type_for_const(db: &impl HirDatabase, def: Const) -> Ty { | 641 | fn type_for_const(db: &impl HirDatabase, def: Const) -> Ty { |
637 | let data = def.data(db); | 642 | let data = def.data(db); |
638 | let resolver = def.resolver(db); | 643 | let resolver = def.id.resolver(db); |
639 | 644 | ||
640 | Ty::from_hir(db, &resolver, data.type_ref()) | 645 | Ty::from_hir(db, &resolver, data.type_ref()) |
641 | } | 646 | } |
@@ -643,7 +648,7 @@ fn type_for_const(db: &impl HirDatabase, def: Const) -> Ty { | |||
643 | /// Build the declared type of a static. | 648 | /// Build the declared type of a static. |
644 | fn type_for_static(db: &impl HirDatabase, def: Static) -> Ty { | 649 | fn type_for_static(db: &impl HirDatabase, def: Static) -> Ty { |
645 | let data = def.data(db); | 650 | let data = def.data(db); |
646 | let resolver = def.resolver(db); | 651 | let resolver = def.id.resolver(db); |
647 | 652 | ||
648 | Ty::from_hir(db, &resolver, data.type_ref()) | 653 | Ty::from_hir(db, &resolver, data.type_ref()) |
649 | } | 654 | } |
@@ -695,7 +700,7 @@ fn fn_sig_for_struct_constructor(db: &impl HirDatabase, def: Struct) -> FnSig { | |||
695 | Some(fields) => fields, | 700 | Some(fields) => fields, |
696 | None => panic!("fn_sig_for_struct_constructor called on unit struct"), | 701 | None => panic!("fn_sig_for_struct_constructor called on unit struct"), |
697 | }; | 702 | }; |
698 | let resolver = def.resolver(db); | 703 | let resolver = def.id.resolver(db); |
699 | let params = fields | 704 | let params = fields |
700 | .iter() | 705 | .iter() |
701 | .map(|(_, field)| Ty::from_hir(db, &resolver, &field.type_ref)) | 706 | .map(|(_, field)| Ty::from_hir(db, &resolver, &field.type_ref)) |
@@ -710,7 +715,7 @@ fn type_for_struct_constructor(db: &impl HirDatabase, def: Struct) -> Ty { | |||
710 | if struct_data.variant_data.fields().is_none() { | 715 | if struct_data.variant_data.fields().is_none() { |
711 | return type_for_adt(db, def); // Unit struct | 716 | return type_for_adt(db, def); // Unit struct |
712 | } | 717 | } |
713 | let generics = def.generic_params(db); | 718 | let generics = db.generic_params(def.id.into()); |
714 | let substs = Substs::identity(&generics); | 719 | let substs = Substs::identity(&generics); |
715 | Ty::apply(TypeCtor::FnDef(def.into()), substs) | 720 | Ty::apply(TypeCtor::FnDef(def.into()), substs) |
716 | } | 721 | } |
@@ -721,12 +726,12 @@ fn fn_sig_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariant) | |||
721 | Some(fields) => fields, | 726 | Some(fields) => fields, |
722 | None => panic!("fn_sig_for_enum_variant_constructor called for unit variant"), | 727 | None => panic!("fn_sig_for_enum_variant_constructor called for unit variant"), |
723 | }; | 728 | }; |
724 | let resolver = def.parent_enum(db).resolver(db); | 729 | let resolver = def.parent.id.resolver(db); |
725 | let params = fields | 730 | let params = fields |
726 | .iter() | 731 | .iter() |
727 | .map(|(_, field)| Ty::from_hir(db, &resolver, &field.type_ref)) | 732 | .map(|(_, field)| Ty::from_hir(db, &resolver, &field.type_ref)) |
728 | .collect::<Vec<_>>(); | 733 | .collect::<Vec<_>>(); |
729 | let generics = def.parent_enum(db).generic_params(db); | 734 | let generics = db.generic_params(def.parent_enum(db).id.into()); |
730 | let substs = Substs::identity(&generics); | 735 | let substs = Substs::identity(&generics); |
731 | let ret = type_for_adt(db, def.parent_enum(db)).subst(&substs); | 736 | let ret = type_for_adt(db, def.parent_enum(db)).subst(&substs); |
732 | FnSig::from_params_and_return(params, ret) | 737 | FnSig::from_params_and_return(params, ret) |
@@ -738,19 +743,21 @@ fn type_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariant) -> | |||
738 | if var_data.fields().is_none() { | 743 | if var_data.fields().is_none() { |
739 | return type_for_adt(db, def.parent_enum(db)); // Unit variant | 744 | return type_for_adt(db, def.parent_enum(db)); // Unit variant |
740 | } | 745 | } |
741 | let generics = def.parent_enum(db).generic_params(db); | 746 | let generics = db.generic_params(def.parent_enum(db).id.into()); |
742 | let substs = Substs::identity(&generics); | 747 | let substs = Substs::identity(&generics); |
743 | Ty::apply(TypeCtor::FnDef(def.into()), substs) | 748 | Ty::apply(TypeCtor::FnDef(def.into()), substs) |
744 | } | 749 | } |
745 | 750 | ||
746 | fn type_for_adt(db: &impl HirDatabase, adt: impl Into<Adt> + HasGenericParams) -> Ty { | 751 | fn type_for_adt(db: &impl HirDatabase, adt: impl Into<Adt>) -> Ty { |
747 | let generics = adt.generic_params(db); | 752 | let adt = adt.into(); |
748 | Ty::apply(TypeCtor::Adt(adt.into()), Substs::identity(&generics)) | 753 | let adt_id: AdtId = adt.into(); |
754 | let generics = db.generic_params(adt_id.into()); | ||
755 | Ty::apply(TypeCtor::Adt(adt), Substs::identity(&generics)) | ||
749 | } | 756 | } |
750 | 757 | ||
751 | fn type_for_type_alias(db: &impl HirDatabase, t: TypeAlias) -> Ty { | 758 | fn type_for_type_alias(db: &impl HirDatabase, t: TypeAlias) -> Ty { |
752 | let generics = t.generic_params(db); | 759 | let generics = db.generic_params(t.id.into()); |
753 | let resolver = t.resolver(db); | 760 | let resolver = t.id.resolver(db); |
754 | let type_ref = t.type_ref(db); | 761 | let type_ref = t.type_ref(db); |
755 | let substs = Substs::identity(&generics); | 762 | let substs = Substs::identity(&generics); |
756 | let inner = Ty::from_hir(db, &resolver, &type_ref.unwrap_or(TypeRef::Error)); | 763 | let inner = Ty::from_hir(db, &resolver, &type_ref.unwrap_or(TypeRef::Error)); |