Refactor associated method resolution a bit and make it work with generics

4 files changed, 98 insertions, 64 deletions

diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
index 6ee9080d3..13080b5aa 100644
--- a/crates/ra_hir/src/ty/infer.rs
+++ b/crates/ra_hir/src/ty/infer.rs
@@ -360,46 +360,66 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         // we might have resolved into a type for which
         // we may find some associated item starting at the
         // path.segment pointed to by `remaining_index´
-        let resolved =
+        let mut resolved =
             if remaining_index.is_none() { def.take_values()? } else { def.take_types()? };
 
+        let remaining_index = remaining_index.unwrap_or(path.segments.len());
+
+        // resolve intermediate segments
+        for segment in &path.segments[remaining_index..] {
+            let ty = match resolved {
+                Resolution::Def(def) => {
+                    let typable: Option<TypableDef> = def.into();
+                    let typable = typable?;
+
+                    let substs =
+                        Ty::substs_from_path_segment(self.db, &self.resolver, segment, typable);
+                    self.db.type_for_def(typable, Namespace::Types).apply_substs(substs)
+                }
+                Resolution::LocalBinding(_) => {
+                    // can't have a local binding in an associated item path
+                    return None;
+                }
+                Resolution::GenericParam(..) => {
+                    // TODO associated item of generic param
+                    return None;
+                }
+                Resolution::SelfType(_) => {
+                    // TODO associated item of self type
+                    return None;
+                }
+            };
+
+            // Attempt to find an impl_item for the type which has a name matching
+            // the current segment
+            log::debug!("looking for path segment: {:?}", segment);
+            let item = ty.iterate_impl_items(self.db, |item| match item {
+                crate::ImplItem::Method(func) => {
+                    let sig = func.signature(self.db);
+                    if segment.name == *sig.name() {
+                        return Some(func);
+                    }
+                    None
+                }
+
+                // TODO: Resolve associated const
+                crate::ImplItem::Const(_) => None,
+
+                // TODO: Resolve associated types
+                crate::ImplItem::Type(_) => None,
+            })?;
+            resolved = Resolution::Def(item.into());
+        }
+
         match resolved {
             Resolution::Def(def) => {
                 let typable: Option<TypableDef> = def.into();
                 let typable = typable?;
 
-                if let Some(remaining_index) = remaining_index {
-                    let ty = self.db.type_for_def(typable, Namespace::Types);
-                    // TODO: Keep resolving the segments
-                    // if we have more segments to process
-                    let segment = &path.segments[remaining_index];
-
-                    log::debug!("looking for path segment: {:?}", segment);
-
-                    // Attempt to find an impl_item for the type which has a name matching
-                    // the current segment
-                    let ty = ty.iterate_impl_items(self.db, |item| match item {
-                        crate::ImplItem::Method(func) => {
-                            let sig = func.signature(self.db);
-                            if segment.name == *sig.name() {
-                                return Some(func.ty(self.db));
-                            }
-                            None
-                        }
-
-                        // TODO: Resolve associated const
-                        crate::ImplItem::Const(_) => None,
-
-                        // TODO: Resolve associated types
-                        crate::ImplItem::Type(_) => None,
-                    });
-                    ty
-                } else {
-                    let substs = Ty::substs_from_path(self.db, &self.resolver, path, typable);
-                    let ty = self.db.type_for_def(typable, Namespace::Values).apply_substs(substs);
-                    let ty = self.insert_type_vars(ty);
-                    Some(ty)
-                }
+                let substs = Ty::substs_from_path(self.db, &self.resolver, path, typable);
+                let ty = self.db.type_for_def(typable, Namespace::Values).apply_substs(substs);
+                let ty = self.insert_type_vars(ty);
+                Some(ty)
             }
             Resolution::LocalBinding(pat) => {
                 let ty = self.type_of_pat.get(pat)?;
diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs
index cc9e0fd40..63e13a30e 100644
--- a/crates/ra_hir/src/ty/lower.rs
+++ b/crates/ra_hir/src/ty/lower.rs
@@ -16,7 +16,7 @@ use crate::{
     name::KnownName,
     nameres::Namespace,
     resolve::{Resolver, Resolution},
-    path::GenericArg,
+    path::{ PathSegment, GenericArg},
     generics::GenericParams,
     adt::VariantDef,
 };
@@ -112,36 +112,18 @@ impl Ty {
         ty.apply_substs(substs)
     }
 
-    /// Collect generic arguments from a path into a `Substs`. See also
-    /// `create_substs_for_ast_path` and `def_to_ty` in rustc.
-    pub(super) fn substs_from_path(
+    pub(super) fn substs_from_path_segment(
         db: &impl HirDatabase,
         resolver: &Resolver,
-        path: &Path,
+        segment: &PathSegment,
         resolved: TypableDef,
     ) -> Substs {
         let mut substs = Vec::new();
-        let last = path.segments.last().expect("path should have at least one segment");
-        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
-                // `Option::None::<T>` are both allowed (though the former is
-                // preferred). See also `def_ids_for_path_segments` in rustc.
-                let len = path.segments.len();
-                let segment = if len >= 2 && path.segments[len - 2].args_and_bindings.is_some() {
-                    // Option::<T>::None
-                    &path.segments[len - 2]
-                } else {
-                    // Option::None::<T>
-                    last
-                };
-                (var.parent_enum(db).generic_params(db), segment)
-            }
+        let def_generics = match resolved {
+            TypableDef::Function(func) => func.generic_params(db),
+            TypableDef::Struct(s) => s.generic_params(db),
+            TypableDef::Enum(e) => e.generic_params(db),
+            TypableDef::EnumVariant(var) => var.parent_enum(db).generic_params(db),
         };
         let parent_param_count = def_generics.count_parent_params();
         substs.extend((0..parent_param_count).map(|_| Ty::Unknown));
@@ -166,6 +148,39 @@ impl Ty {
         assert_eq!(substs.len(), def_generics.count_params_including_parent());
         Substs(substs.into())
     }
+
+    /// Collect generic arguments from a path into a `Substs`. See also
+    /// `create_substs_for_ast_path` and `def_to_ty` in rustc.
+    pub(super) fn substs_from_path(
+        db: &impl HirDatabase,
+        resolver: &Resolver,
+        path: &Path,
+        resolved: TypableDef,
+    ) -> Substs {
+        let last = path.segments.last().expect("path should have at least one segment");
+        let segment = match resolved {
+            TypableDef::Function(_) => last,
+            TypableDef::Struct(_) => last,
+            TypableDef::Enum(_) => last,
+            TypableDef::EnumVariant(_) => {
+                // 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
+                // `Option::None::<T>` are both allowed (though the former is
+                // preferred). See also `def_ids_for_path_segments` in rustc.
+                let len = path.segments.len();
+                let segment = if len >= 2 && path.segments[len - 2].args_and_bindings.is_some() {
+                    // Option::<T>::None
+                    &path.segments[len - 2]
+                } else {
+                    // Option::None::<T>
+                    last
+                };
+                segment
+            }
+        };
+        Ty::substs_from_path_segment(db, resolver, segment, resolved)
+    }
 }
 
 /// Build the declared type of an item. This depends on the namespace; e.g. for
diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_associated_method_generics.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_associated_method_generics.snap
index fe5d6590e..44694dfdb 100644
--- a/crates/ra_hir/src/ty/snapshots/tests__infer_associated_method_generics.snap
+++ b/crates/ra_hir/src/ty/snapshots/tests__infer_associated_method_generics.snap
@@ -1,5 +1,5 @@
 ---
-created: "2019-02-21T10:25:18.568887300Z"
+created: "2019-02-23T21:58:35.844769207Z"
 creator: [email protected]
 source: crates/ra_hir/src/ty/tests.rs
 expression: "&result"
@@ -9,8 +9,8 @@ expression: "&result"
 [92; 103) 'Gen { val }': Gen<T>
 [98; 101) 'val': T
 [123; 155) '{     ...32); }': ()
-[133; 134) 'a': Gen<[unknown]>
-[137; 146) 'Gen::make': fn make<[unknown]>(T) -> Gen<T>
-[137; 152) 'Gen::make(0u32)': Gen<[unknown]>
+[133; 134) 'a': Gen<u32>
+[137; 146) 'Gen::make': fn make<u32>(T) -> Gen<T>
+[137; 152) 'Gen::make(0u32)': Gen<u32>
 [147; 151) '0u32': u32
 
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
index 77aeca669..d0da34677 100644
--- a/crates/ra_hir/src/ty/tests.rs
+++ b/crates/ra_hir/src/ty/tests.rs
@@ -719,7 +719,6 @@ fn test() {
 }
 
 #[test]
-#[ignore] // FIXME: After https://github.com/rust-analyzer/rust-analyzer/pull/866 is merged
 fn infer_associated_method_generics() {
     check_inference(
         "infer_associated_method_generics",