1 files changed, 85 insertions, 79 deletions

diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs
index 2272510e8..27cfe00c1 100644
--- a/crates/ra_hir/src/ty/lower.rs
+++ b/crates/ra_hir/src/ty/lower.rs
@@ -14,12 +14,15 @@ use hir_def::{
     path::{GenericArg, PathSegment},
     resolver::{HasResolver, Resolver, TypeNs},
     type_ref::{TypeBound, TypeRef},
-    AdtId, GenericDefId,
+    AdtId, AstItemDef, EnumVariantId, FunctionId, GenericDefId, HasModule, LocalStructFieldId,
+    Lookup, StructId, VariantId,
 };
+use ra_arena::map::ArenaMap;
+use ra_db::CrateId;
 
 use super::{
-    FnSig, GenericPredicate, ProjectionPredicate, ProjectionTy, Substs, TraitRef, Ty, TypeCtor,
-    TypeWalk,
+    FnSig, GenericPredicate, ProjectionPredicate, ProjectionTy, Substs, TraitEnvironment, TraitRef,
+    Ty, TypeCtor, TypeWalk,
 };
 use crate::{
     db::HirDatabase,
@@ -28,8 +31,8 @@ use crate::{
         Adt,
     },
     util::make_mut_slice,
-    Const, Enum, EnumVariant, Function, GenericDef, ImplBlock, ModuleDef, Path, Static, Struct,
-    StructField, Trait, TypeAlias, Union, VariantDef,
+    Const, Enum, EnumVariant, Function, ImplBlock, ModuleDef, Path, Static, Struct, Trait,
+    TypeAlias, Union,
 };
 
 // FIXME: this is only really used in `type_for_def`, which contains a bunch of
@@ -260,8 +263,10 @@ impl Ty {
         let traits = traits_from_env.flat_map(|t| t.all_super_traits(db));
         for t in traits {
             if let Some(associated_ty) = t.associated_type_by_name(db, &segment.name) {
-                let substs =
-                    Substs::build_for_def(db, t).push(self_ty.clone()).fill_with_unknown().build();
+                let substs = Substs::build_for_def(db, t.id)
+                    .push(self_ty.clone())
+                    .fill_with_unknown()
+                    .build();
                 // FIXME handle type parameters on the segment
                 return Ty::Projection(ProjectionTy { associated_ty, parameters: substs });
             }
@@ -286,11 +291,11 @@ impl Ty {
         segment: &PathSegment,
         resolved: TypableDef,
     ) -> Substs {
-        let def_generic: Option<GenericDef> = match resolved {
-            TypableDef::Function(func) => Some(func.into()),
+        let def_generic: Option<GenericDefId> = match resolved {
+            TypableDef::Function(func) => Some(func.id.into()),
             TypableDef::Adt(adt) => Some(adt.into()),
-            TypableDef::EnumVariant(var) => Some(var.parent_enum(db).into()),
-            TypableDef::TypeAlias(t) => Some(t.into()),
+            TypableDef::EnumVariant(var) => Some(var.parent_enum(db).id.into()),
+            TypableDef::TypeAlias(t) => Some(t.id.into()),
             TypableDef::Const(_) | TypableDef::Static(_) | TypableDef::BuiltinType(_) => None,
         };
         substs_from_path_segment(db, resolver, segment, def_generic, false)
@@ -337,7 +342,7 @@ pub(super) fn substs_from_path_segment(
     db: &impl HirDatabase,
     resolver: &Resolver,
     segment: &PathSegment,
-    def_generic: Option<GenericDef>,
+    def_generic: Option<GenericDefId>,
     add_self_param: bool,
 ) -> Substs {
     let mut substs = Vec::new();
@@ -375,7 +380,7 @@ pub(super) fn substs_from_path_segment(
 
     // handle defaults
     if let Some(def_generic) = def_generic {
-        let default_substs = db.generic_defaults(def_generic);
+        let default_substs = db.generic_defaults(def_generic.into());
         assert_eq!(substs.len(), default_substs.len());
 
         for (i, default_ty) in default_substs.iter().enumerate() {
@@ -438,7 +443,7 @@ impl TraitRef {
     ) -> Substs {
         let has_self_param =
             segment.args_and_bindings.as_ref().map(|a| a.has_self_type).unwrap_or(false);
-        substs_from_path_segment(db, resolver, segment, Some(resolved.into()), !has_self_param)
+        substs_from_path_segment(db, resolver, segment, Some(resolved.id.into()), !has_self_param)
     }
 
     pub(crate) fn for_trait(db: &impl HirDatabase, trait_: Trait) -> TraitRef {
@@ -543,22 +548,29 @@ pub(crate) fn type_for_def(db: &impl HirDatabase, def: TypableDef, ns: Namespace
 /// Build the signature of a callable item (function, struct or enum variant).
 pub(crate) fn callable_item_sig(db: &impl HirDatabase, def: CallableDef) -> FnSig {
     match def {
-        CallableDef::Function(f) => fn_sig_for_fn(db, f),
-        CallableDef::Struct(s) => fn_sig_for_struct_constructor(db, s),
-        CallableDef::EnumVariant(e) => fn_sig_for_enum_variant_constructor(db, e),
+        CallableDef::FunctionId(f) => fn_sig_for_fn(db, f),
+        CallableDef::StructId(s) => fn_sig_for_struct_constructor(db, s),
+        CallableDef::EnumVariantId(e) => fn_sig_for_enum_variant_constructor(db, e),
     }
 }
 
-/// Build the type of a specific field of a struct or enum variant.
-pub(crate) fn type_for_field(db: &impl HirDatabase, field: StructField) -> Ty {
-    let parent_def = field.parent_def(db);
-    let resolver = match parent_def {
-        VariantDef::Struct(it) => it.id.resolver(db),
-        VariantDef::EnumVariant(it) => it.parent.id.resolver(db),
+/// Build the type of all specific fields of a struct or enum variant.
+pub(crate) fn field_types_query(
+    db: &impl HirDatabase,
+    variant_id: VariantId,
+) -> Arc<ArenaMap<LocalStructFieldId, Ty>> {
+    let (resolver, var_data) = match variant_id {
+        VariantId::StructId(it) => (it.resolver(db), db.struct_data(it.0).variant_data.clone()),
+        VariantId::EnumVariantId(it) => (
+            it.parent.resolver(db),
+            db.enum_data(it.parent).variants[it.local_id].variant_data.clone(),
+        ),
     };
-    let var_data = parent_def.variant_data(db);
-    let type_ref = &var_data.fields().unwrap()[field.id].type_ref;
-    Ty::from_hir(db, &resolver, type_ref)
+    let mut res = ArenaMap::default();
+    for (field_id, field_data) in var_data.fields().iter() {
+        res.insert(field_id, Ty::from_hir(db, &resolver, &field_data.type_ref))
+    }
+    Arc::new(res)
 }
 
 /// This query exists only to be used when resolving short-hand associated types
@@ -571,10 +583,10 @@ pub(crate) fn type_for_field(db: &impl HirDatabase, field: StructField) -> Ty {
 /// these are fine: `T: Foo<U::Item>, U: Foo<()>`.
 pub(crate) fn generic_predicates_for_param_query(
     db: &impl HirDatabase,
-    def: GenericDef,
+    def: GenericDefId,
     param_idx: u32,
 ) -> Arc<[GenericPredicate]> {
-    let resolver = GenericDefId::from(def).resolver(db);
+    let resolver = def.resolver(db);
     resolver
         .where_predicates_in_scope()
         // we have to filter out all other predicates *first*, before attempting to lower them
@@ -583,24 +595,23 @@ pub(crate) fn generic_predicates_for_param_query(
         .collect()
 }
 
-pub(crate) fn trait_env(
-    db: &impl HirDatabase,
-    resolver: &Resolver,
-) -> Arc<super::TraitEnvironment> {
-    let predicates = resolver
-        .where_predicates_in_scope()
-        .flat_map(|pred| GenericPredicate::from_where_predicate(db, &resolver, pred))
-        .collect::<Vec<_>>();
+impl TraitEnvironment {
+    pub(crate) fn lower(db: &impl HirDatabase, resolver: &Resolver) -> Arc<TraitEnvironment> {
+        let predicates = resolver
+            .where_predicates_in_scope()
+            .flat_map(|pred| GenericPredicate::from_where_predicate(db, &resolver, pred))
+            .collect::<Vec<_>>();
 
-    Arc::new(super::TraitEnvironment { predicates })
+        Arc::new(TraitEnvironment { predicates })
+    }
 }
 
 /// Resolve the where clause(s) of an item with generics.
 pub(crate) fn generic_predicates_query(
     db: &impl HirDatabase,
-    def: GenericDef,
+    def: GenericDefId,
 ) -> Arc<[GenericPredicate]> {
-    let resolver = GenericDefId::from(def).resolver(db);
+    let resolver = def.resolver(db);
     resolver
         .where_predicates_in_scope()
         .flat_map(|pred| GenericPredicate::from_where_predicate(db, &resolver, pred))
@@ -608,8 +619,8 @@ pub(crate) fn generic_predicates_query(
 }
 
 /// Resolve the default type params from generics
-pub(crate) fn generic_defaults_query(db: &impl HirDatabase, def: GenericDef) -> Substs {
-    let resolver = GenericDefId::from(def).resolver(db);
+pub(crate) fn generic_defaults_query(db: &impl HirDatabase, def: GenericDefId) -> Substs {
+    let resolver = def.resolver(db);
     let generic_params = db.generic_params(def.into());
 
     let defaults = generic_params
@@ -621,9 +632,9 @@ pub(crate) fn generic_defaults_query(db: &impl HirDatabase, def: GenericDef) ->
     Substs(defaults)
 }
 
-fn fn_sig_for_fn(db: &impl HirDatabase, def: Function) -> FnSig {
-    let data = db.function_data(def.id);
-    let resolver = def.id.resolver(db);
+fn fn_sig_for_fn(db: &impl HirDatabase, def: FunctionId) -> FnSig {
+    let data = db.function_data(def);
+    let resolver = def.resolver(db);
     let params = data.params.iter().map(|tr| Ty::from_hir(db, &resolver, tr)).collect::<Vec<_>>();
     let ret = Ty::from_hir(db, &resolver, &data.ret_type);
     FnSig::from_params_and_return(params, ret)
@@ -634,7 +645,7 @@ fn fn_sig_for_fn(db: &impl HirDatabase, def: Function) -> FnSig {
 fn type_for_fn(db: &impl HirDatabase, def: Function) -> Ty {
     let generics = db.generic_params(def.id.into());
     let substs = Substs::identity(&generics);
-    Ty::apply(TypeCtor::FnDef(def.into()), substs)
+    Ty::apply(TypeCtor::FnDef(def.id.into()), substs)
 }
 
 /// Build the declared type of a const.
@@ -694,58 +705,53 @@ impl From<Option<BuiltinFloat>> for Uncertain<FloatTy> {
     }
 }
 
-fn fn_sig_for_struct_constructor(db: &impl HirDatabase, def: Struct) -> FnSig {
-    let struct_data = db.struct_data(def.id.into());
-    let fields = match struct_data.variant_data.fields() {
-        Some(fields) => fields,
-        None => panic!("fn_sig_for_struct_constructor called on unit struct"),
-    };
-    let resolver = def.id.resolver(db);
+fn fn_sig_for_struct_constructor(db: &impl HirDatabase, def: StructId) -> FnSig {
+    let struct_data = db.struct_data(def.into());
+    let fields = struct_data.variant_data.fields();
+    let resolver = def.resolver(db);
     let params = fields
         .iter()
         .map(|(_, field)| Ty::from_hir(db, &resolver, &field.type_ref))
         .collect::<Vec<_>>();
-    let ret = type_for_adt(db, def);
+    let ret = type_for_adt(db, Struct::from(def));
     FnSig::from_params_and_return(params, ret)
 }
 
 /// Build the type of a tuple struct constructor.
 fn type_for_struct_constructor(db: &impl HirDatabase, def: Struct) -> Ty {
     let struct_data = db.struct_data(def.id.into());
-    if struct_data.variant_data.fields().is_none() {
+    if struct_data.variant_data.is_unit() {
         return type_for_adt(db, def); // Unit struct
     }
     let generics = db.generic_params(def.id.into());
     let substs = Substs::identity(&generics);
-    Ty::apply(TypeCtor::FnDef(def.into()), substs)
+    Ty::apply(TypeCtor::FnDef(def.id.into()), substs)
 }
 
-fn fn_sig_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariant) -> FnSig {
-    let var_data = def.variant_data(db);
-    let fields = match var_data.fields() {
-        Some(fields) => fields,
-        None => panic!("fn_sig_for_enum_variant_constructor called for unit variant"),
-    };
-    let resolver = def.parent.id.resolver(db);
+fn fn_sig_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariantId) -> FnSig {
+    let enum_data = db.enum_data(def.parent);
+    let var_data = &enum_data.variants[def.local_id];
+    let fields = var_data.variant_data.fields();
+    let resolver = def.parent.resolver(db);
     let params = fields
         .iter()
         .map(|(_, field)| Ty::from_hir(db, &resolver, &field.type_ref))
         .collect::<Vec<_>>();
-    let generics = db.generic_params(def.parent_enum(db).id.into());
+    let generics = db.generic_params(def.parent.into());
     let substs = Substs::identity(&generics);
-    let ret = type_for_adt(db, def.parent_enum(db)).subst(&substs);
+    let ret = type_for_adt(db, Enum::from(def.parent)).subst(&substs);
     FnSig::from_params_and_return(params, ret)
 }
 
 /// Build the type of a tuple enum variant constructor.
 fn type_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariant) -> Ty {
     let var_data = def.variant_data(db);
-    if var_data.fields().is_none() {
+    if var_data.is_unit() {
         return type_for_adt(db, def.parent_enum(db)); // Unit variant
     }
     let generics = db.generic_params(def.parent_enum(db).id.into());
     let substs = Substs::identity(&generics);
-    Ty::apply(TypeCtor::FnDef(def.into()), substs)
+    Ty::apply(TypeCtor::FnDef(EnumVariantId::from(def).into()), substs)
 }
 
 fn type_for_adt(db: &impl HirDatabase, adt: impl Into<Adt>) -> Ty {
@@ -802,28 +808,28 @@ impl From<ModuleDef> for Option<TypableDef> {
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub enum CallableDef {
-    Function(Function),
-    Struct(Struct),
-    EnumVariant(EnumVariant),
+    FunctionId(FunctionId),
+    StructId(StructId),
+    EnumVariantId(EnumVariantId),
 }
-impl_froms!(CallableDef: Function, Struct, EnumVariant);
+impl_froms!(CallableDef: FunctionId, StructId, EnumVariantId);
 
 impl CallableDef {
-    pub fn krate(self, db: &impl HirDatabase) -> Option<crate::Crate> {
+    pub fn krate(self, db: &impl HirDatabase) -> CrateId {
         match self {
-            CallableDef::Function(f) => f.krate(db),
-            CallableDef::Struct(s) => s.krate(db),
-            CallableDef::EnumVariant(e) => e.parent_enum(db).krate(db),
+            CallableDef::FunctionId(f) => f.lookup(db).module(db).krate,
+            CallableDef::StructId(s) => s.0.module(db).krate,
+            CallableDef::EnumVariantId(e) => e.parent.module(db).krate,
         }
     }
 }
 
-impl From<CallableDef> for GenericDef {
-    fn from(def: CallableDef) -> GenericDef {
+impl From<CallableDef> for GenericDefId {
+    fn from(def: CallableDef) -> GenericDefId {
         match def {
-            CallableDef::Function(f) => f.into(),
-            CallableDef::Struct(s) => s.into(),
-            CallableDef::EnumVariant(e) => e.into(),
+            CallableDef::FunctionId(f) => f.into(),
+            CallableDef::StructId(s) => s.into(),
+            CallableDef::EnumVariantId(e) => e.into(),
         }
     }
 }