1 files changed, 117 insertions, 101 deletions

diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
index e690ae158..c7f77e7a3 100644
--- a/crates/ra_hir/src/ty.rs
+++ b/crates/ra_hir/src/ty.rs
@@ -24,15 +24,14 @@ use std::ops::Index;
 use std::sync::Arc;
 use std::{fmt, mem};
 
-use log;
 use ena::unify::{InPlaceUnificationTable, UnifyKey, UnifyValue, NoError};
 use ra_arena::map::ArenaMap;
 use join_to_string::join;
 use rustc_hash::FxHashMap;
 
 use crate::{
-    Def, DefId, Module, Function, Struct, StructField, Enum, EnumVariant, Path, Name, ImplBlock,
-    FnSignature, FnScopes,
+    Module, Function, Struct, StructField, Enum, EnumVariant, Path, Name, ImplBlock,
+    FnSignature, FnScopes, ModuleDef, AdtDef,
     db::HirDatabase,
     type_ref::{TypeRef, Mutability},
     name::KnownName,
@@ -184,7 +183,7 @@ pub enum Ty {
     /// Structures, enumerations and unions.
     Adt {
         /// The DefId of the struct/enum.
-        def_id: DefId,
+        def_id: AdtDef,
         /// The name, for displaying.
         name: Name,
         /// Substitutions for the generic parameters of the type.
@@ -381,12 +380,16 @@ impl Ty {
         }
 
         // Resolve in module (in type namespace)
-        let resolved = match module.resolve_path(db, path).take_types() {
-            Some(r) => r,
+        let typable: TypableDef = match module
+            .resolve_path(db, path)
+            .take_types()
+            .and_then(|it| it.into())
+        {
             None => return Ty::Unknown,
+            Some(it) => it,
         };
-        let ty = db.type_for_def(resolved);
-        let substs = Ty::substs_from_path(db, module, impl_block, generics, path, resolved);
+        let ty = db.type_for_def(typable);
+        let substs = Ty::substs_from_path(db, module, impl_block, generics, path, typable);
         ty.apply_substs(substs)
     }
 
@@ -399,20 +402,18 @@ impl Ty {
         impl_block: Option<&ImplBlock>,
         outer_generics: &GenericParams,
         path: &Path,
-        resolved: DefId,
+        resolved: TypableDef,
     ) -> Substs {
         let mut substs = Vec::new();
-        let def = resolved.resolve(db);
         let last = path
             .segments
             .last()
             .expect("path should have at least one segment");
-        let (def_generics, segment) = match def {
-            Def::Struct(s) => (s.generic_params(db), last),
-            Def::Enum(e) => (e.generic_params(db), last),
-            Def::Function(f) => (f.generic_params(db), last),
-            Def::Trait(t) => (t.generic_params(db), last),
-            Def::EnumVariant(ev) => {
+        let (def_generics, segment) = match resolved {
+            TypableDef::Function(func) => (func.generic_params(db), last),
+            TypableDef::Struct(s) => (s.generic_params(db), last),
+            TypableDef::Enum(e) => (e.generic_params(db), last),
+            TypableDef::EnumVariant(var) => {
                 // the generic args for an enum variant may be either specified
                 // on the segment referring to the enum, or on the segment
                 // referring to the variant. So `Option::<T>::None` and
@@ -426,9 +427,8 @@ impl Ty {
                     // Option::None::<T>
                     last
                 };
-                (ev.parent_enum(db).generic_params(db), segment)
+                (var.parent_enum(db).generic_params(db), segment)
             }
-            _ => return Substs::empty(),
         };
         // substs_from_path
         if let Some(generic_args) = &segment.args_and_bindings {
@@ -639,7 +639,7 @@ fn make_substs(generics: &GenericParams) -> Substs {
 fn type_for_struct(db: &impl HirDatabase, s: Struct) -> Ty {
     let generics = s.generic_params(db);
     Ty::Adt {
-        def_id: s.def_id(),
+        def_id: s.into(),
         name: s.name(db).unwrap_or_else(Name::missing),
         substs: make_substs(&generics),
     }
@@ -648,7 +648,7 @@ fn type_for_struct(db: &impl HirDatabase, s: Struct) -> Ty {
 pub(crate) fn type_for_enum(db: &impl HirDatabase, s: Enum) -> Ty {
     let generics = s.generic_params(db);
     Ty::Adt {
-        def_id: s.def_id(),
+        def_id: s.into(),
         name: s.name(db).unwrap_or_else(Name::missing),
         substs: make_substs(&generics),
     }
@@ -660,66 +660,74 @@ pub(crate) fn type_for_enum_variant(db: &impl HirDatabase, ev: EnumVariant) -> T
     type_for_enum(db, enum_parent)
 }
 
-pub(super) fn type_for_def(db: &impl HirDatabase, def_id: DefId) -> Ty {
-    let def = def_id.resolve(db);
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum TypableDef {
+    Function(Function),
+    Struct(Struct),
+    Enum(Enum),
+    EnumVariant(EnumVariant),
+}
+impl_froms!(TypableDef: Function, Struct, Enum, EnumVariant);
+
+impl From<ModuleDef> for Option<TypableDef> {
+    fn from(def: ModuleDef) -> Option<TypableDef> {
+        let res = match def {
+            ModuleDef::Function(f) => f.into(),
+            ModuleDef::Struct(s) => s.into(),
+            ModuleDef::Enum(e) => e.into(),
+            ModuleDef::EnumVariant(v) => v.into(),
+            ModuleDef::Const(_)
+            | ModuleDef::Static(_)
+            | ModuleDef::Module(_)
+            | ModuleDef::Trait(_)
+            | ModuleDef::Type(_) => return None,
+        };
+        Some(res)
+    }
+}
+
+pub(super) fn type_for_def(db: &impl HirDatabase, def: TypableDef) -> Ty {
     match def {
-        Def::Module(..) => {
-            log::debug!("trying to get type for module {:?}", def_id);
-            Ty::Unknown
-        }
-        Def::Function(f) => type_for_fn(db, f),
-        Def::Struct(s) => type_for_struct(db, s),
-        Def::Enum(e) => type_for_enum(db, e),
-        Def::EnumVariant(ev) => type_for_enum_variant(db, ev),
-        _ => {
-            log::debug!(
-                "trying to get type for item of unknown type {:?} {:?}",
-                def_id,
-                def
-            );
-            Ty::Unknown
-        }
+        TypableDef::Function(f) => type_for_fn(db, f),
+        TypableDef::Struct(s) => type_for_struct(db, s),
+        TypableDef::Enum(e) => type_for_enum(db, e),
+        TypableDef::EnumVariant(v) => type_for_enum_variant(db, v),
     }
 }
 
-pub(super) fn type_for_field(db: &impl HirDatabase, def_id: DefId, field: Name) -> Option<Ty> {
-    let def = def_id.resolve(db);
-    let (variant_data, generics) = match def {
-        Def::Struct(s) => (s.variant_data(db), s.generic_params(db)),
-        Def::EnumVariant(ev) => (ev.variant_data(db), ev.parent_enum(db).generic_params(db)),
-        // TODO: unions
-        Def::Enum(_) => {
-            // this can happen in (invalid) code, but enums don't have fields themselves
-            return None;
-        }
-        _ => panic!(
-            "trying to get type for field {:?} in non-struct/variant {:?}",
-            field, def_id
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum VariantDef {
+    Struct(Struct),
+    EnumVariant(EnumVariant),
+}
+impl_froms!(VariantDef: Struct, EnumVariant);
+
+pub(super) fn type_for_field(db: &impl HirDatabase, def: VariantDef, field: Name) -> Option<Ty> {
+    let (variant_data, generics, module) = match def {
+        VariantDef::Struct(s) => (s.variant_data(db), s.generic_params(db), s.module(db)),
+        VariantDef::EnumVariant(var) => (
+            var.variant_data(db),
+            var.parent_enum(db).generic_params(db),
+            var.module(db),
         ),
     };
-    let module = def_id.module(db);
-    let impl_block = def_id.impl_block(db);
+    // We can't have an impl block ere, right?
+    // let impl_block = def_id.impl_block(db);
     let type_ref = variant_data.get_field_type_ref(&field)?;
-    Some(Ty::from_hir(
-        db,
-        &module,
-        impl_block.as_ref(),
-        &generics,
-        &type_ref,
-    ))
+    Some(Ty::from_hir(db, &module, None, &generics, &type_ref))
 }
 
 /// The result of type inference: A mapping from expressions and patterns to types.
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct InferenceResult {
     /// For each method call expr, record the function it resolved to.
-    method_resolutions: FxHashMap<ExprId, DefId>,
+    method_resolutions: FxHashMap<ExprId, Function>,
     type_of_expr: ArenaMap<ExprId, Ty>,
     type_of_pat: ArenaMap<PatId, Ty>,
 }
 
 impl InferenceResult {
-    pub fn method_resolution(&self, expr: ExprId) -> Option<DefId> {
+    pub fn method_resolution(&self, expr: ExprId) -> Option<Function> {
         self.method_resolutions.get(&expr).map(|it| *it)
     }
 }
@@ -749,7 +757,7 @@ struct InferenceContext<'a, D: HirDatabase> {
     module: Module,
     impl_block: Option<ImplBlock>,
     var_unification_table: InPlaceUnificationTable<TypeVarId>,
-    method_resolutions: FxHashMap<ExprId, DefId>,
+    method_resolutions: FxHashMap<ExprId, Function>,
     type_of_expr: ArenaMap<ExprId, Ty>,
     type_of_pat: ArenaMap<PatId, Ty>,
     /// The return type of the function being inferred.
@@ -875,8 +883,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         self.type_of_expr.insert(expr, ty);
     }
 
-    fn write_method_resolution(&mut self, expr: ExprId, def_id: DefId) {
-        self.method_resolutions.insert(expr, def_id);
+    fn write_method_resolution(&mut self, expr: ExprId, func: Function) {
+        self.method_resolutions.insert(expr, func);
     }
 
     fn write_pat_ty(&mut self, pat: PatId, ty: Ty) {
@@ -1063,20 +1071,30 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         };
 
         // resolve in module
-        let resolved = self.module.resolve_path(self.db, &path).take_values()?;
-        let ty = self.db.type_for_def(resolved);
+        let typable: Option<TypableDef> = self
+            .module
+            .resolve_path(self.db, &path)
+            .take_values()?
+            .into();
+        let typable = typable?;
+        let ty = self.db.type_for_def(typable);
         let ty = self.insert_type_vars(ty);
         Some(ty)
     }
 
-    fn resolve_variant(&mut self, path: Option<&Path>) -> (Ty, Option<DefId>) {
+    fn resolve_variant(&mut self, path: Option<&Path>) -> (Ty, Option<VariantDef>) {
         let path = match path {
             Some(path) => path,
             None => return (Ty::Unknown, None),
         };
-        let def_id = match self.module.resolve_path(self.db, &path).take_types() {
-            Some(def_id) => def_id,
-            _ => return (Ty::Unknown, None),
+        let typable: Option<TypableDef> = self
+            .module
+            .resolve_path(self.db, &path)
+            .take_types()
+            .and_then(|it| it.into());
+        let def = match typable {
+            None => return (Ty::Unknown, None),
+            Some(it) => it,
         };
         // TODO remove the duplication between here and `Ty::from_path`?
         // TODO provide generics of function
@@ -1087,38 +1105,34 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             self.impl_block.as_ref(),
             &generics,
             path,
-            def_id,
+            def,
         );
-        match def_id.resolve(self.db) {
-            Def::Struct(s) => {
+        match def {
+            TypableDef::Struct(s) => {
                 let ty = type_for_struct(self.db, s);
                 let ty = self.insert_type_vars(ty.apply_substs(substs));
-                (ty, Some(def_id))
+                (ty, Some(s.into()))
             }
-            Def::EnumVariant(ev) => {
-                let ty = type_for_enum_variant(self.db, ev);
+            TypableDef::EnumVariant(var) => {
+                let ty = type_for_enum_variant(self.db, var);
                 let ty = self.insert_type_vars(ty.apply_substs(substs));
-                (ty, Some(def_id))
+                (ty, Some(var.into()))
             }
-            _ => (Ty::Unknown, None),
+            TypableDef::Enum(_) | TypableDef::Function(_) => (Ty::Unknown, None),
         }
     }
 
     fn resolve_fields(&mut self, path: Option<&Path>) -> Option<(Ty, Vec<StructField>)> {
-        let (ty, def_id) = self.resolve_variant(path);
-        let def_id = def_id?;
-        let def = def_id.resolve(self.db);
-
-        match def {
-            Def::Struct(s) => {
+        let (ty, def) = self.resolve_variant(path);
+        match def? {
+            VariantDef::Struct(s) => {
                 let fields = s.fields(self.db);
                 Some((ty, fields))
             }
-            Def::EnumVariant(ev) => {
-                let fields = ev.fields(self.db);
+            VariantDef::EnumVariant(var) => {
+                let fields = var.fields(self.db);
                 Some((ty, fields))
             }
-            _ => None,
         }
     }
 
@@ -1216,6 +1230,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 .module
                 .resolve_path(self.db, &path)
                 .take_values()
+                .and_then(|module_def| module_def.into())
                 .map_or(Ty::Unknown, |resolved| self.db.type_for_def(resolved)),
             Pat::Bind {
                 mode,
@@ -1336,9 +1351,9 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 let receiver_ty = self.infer_expr(*receiver, &Expectation::none());
                 let resolved = receiver_ty.clone().lookup_method(self.db, method_name);
                 let method_ty = match resolved {
-                    Some(def_id) => {
-                        self.write_method_resolution(expr, def_id);
-                        self.db.type_for_def(def_id)
+                    Some(func) => {
+                        self.write_method_resolution(expr, func);
+                        self.db.type_for_def(func.into())
                     }
                     None => Ty::Unknown,
                 };
@@ -1407,7 +1422,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 for field in fields {
                     let field_ty = if let Some(def_id) = def_id {
                         self.db
-                            .type_for_field(def_id, field.name.clone())
+                            .type_for_field(def_id.into(), field.name.clone())
                             .unwrap_or(Ty::Unknown)
                             .subst(&substs)
                     } else {
@@ -1431,10 +1446,12 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                             i.and_then(|i| fields.get(i).cloned())
                         }
                         Ty::Adt {
-                            def_id, ref substs, ..
+                            def_id: AdtDef::Struct(s),
+                            ref substs,
+                            ..
                         } => self
                             .db
-                            .type_for_field(def_id, name.clone())
+                            .type_for_field(s.into(), name.clone())
                             .map(|ty| ty.subst(substs)),
                         _ => None,
                     })
@@ -1607,16 +1624,15 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
     }
 }
 
-pub fn infer(db: &impl HirDatabase, def_id: DefId) -> Arc<InferenceResult> {
+pub fn infer(db: &impl HirDatabase, func: Function) -> Arc<InferenceResult> {
     db.check_canceled();
-    let function = Function::new(def_id); // TODO: consts also need inference
-    let body = function.body(db);
-    let scopes = db.fn_scopes(def_id);
-    let module = function.module(db);
-    let impl_block = function.impl_block(db);
+    let body = func.body(db);
+    let scopes = db.fn_scopes(func);
+    let module = func.module(db);
+    let impl_block = func.impl_block(db);
     let mut ctx = InferenceContext::new(db, body, scopes, module, impl_block);
 
-    let signature = function.signature(db);
+    let signature = func.signature(db);
     ctx.collect_fn_signature(&signature);
 
     ctx.infer_body();