Merge #866

866: Implement basic support for Associated Methods r=flodiebold a=vipentti

This is my attempt at learning to understand how the type inference works by adding basic support for associated methods. Currently it does not resolve associated types or constants. 

The basic idea is that `Resolver::resolve_path` returns a new `PathResult` type, which has two variants, `FullyResolved` and `PartiallyResolved`, fully resolved matches the previous behavior, where as `PartiallyResolved` contains the `PerNs<Resolution` in addition to a `segment_index` which contains the index of the segment which we failed to resolve. This index can then be used to continue inference in `infer_path_expr` using the `Type` we managed to resolve.

This changes some of the previous apis, so looking for feedback and suggestions.

This should enable fixing #832

Co-authored-by: Ville Penttinen <[email protected]>

1 files changed, 46 insertions, 6 deletions

diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
index 1a3e1994f..ae595c16d 100644
--- a/crates/ra_hir/src/ty.rs
+++ b/crates/ra_hir/src/ty.rs
@@ -37,7 +37,7 @@ use crate::{
     FnSignature, ModuleDef, AdtDef,
     HirDatabase,
     type_ref::{TypeRef, Mutability},
-    name::KnownName,
+    name::{KnownName},
     expr::{Body, Expr, BindingAnnotation, Literal, ExprId, Pat, PatId, UnaryOp, BinaryOp, Statement, FieldPat, self},
     generics::GenericParams,
     path::{ GenericArgs, GenericArg},
@@ -1166,15 +1166,55 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
     }
 
     fn infer_path_expr(&mut self, resolver: &Resolver, path: &Path) -> Option<Ty> {
-        let resolved = resolver.resolve_path(self.db, &path).take_values()?;
+        let resolved = resolver.resolve_path_segments(self.db, &path);
+
+        let (def, remaining_index) = resolved.into_inner();
+
+        // if the remaining_index is None, we expect the path
+        // to be fully resolved, in this case we continue with
+        // the default by attempting to `take_values´ from the resolution.
+        // Otherwise the path was partially resolved, which means
+        // 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 =
+            if remaining_index.is_none() { def.take_values()? } else { def.take_types()? };
+
         match resolved {
             Resolution::Def(def) => {
                 let typable: Option<TypableDef> = def.into();
                 let typable = typable?;
-                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)
+
+                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];
+
+                    // 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(type_for_fn(self.db, func));
+                            }
+                            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)
+                }
             }
             Resolution::LocalBinding(pat) => {
                 let ty = self.type_of_pat.get(pat)?;