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, 58 insertions, 19 deletions

diff --git a/crates/ra_hir/src/nameres.rs b/crates/ra_hir/src/nameres.rs
index bd920bfea..8067b8415 100644
--- a/crates/ra_hir/src/nameres.rs
+++ b/crates/ra_hir/src/nameres.rs
@@ -297,7 +297,14 @@ where
             );
             (res, if res.is_none() { ReachedFixedPoint::No } else { ReachedFixedPoint::Yes })
         } else {
-            self.result.resolve_path_fp(self.db, ResolveMode::Import, original_module, &import.path)
+            let res = self.result.resolve_path_fp(
+                self.db,
+                ResolveMode::Import,
+                original_module,
+                &import.path,
+            );
+
+            (res.resolved_def, res.reached_fixedpoint)
         };
 
         if reached_fixedpoint != ReachedFixedPoint::Yes {
@@ -435,6 +442,27 @@ where
     }
 }
 
+#[derive(Debug, Clone)]
+struct ResolvePathResult {
+    resolved_def: PerNs<ModuleDef>,
+    segment_index: Option<usize>,
+    reached_fixedpoint: ReachedFixedPoint,
+}
+
+impl ResolvePathResult {
+    fn empty(reached_fixedpoint: ReachedFixedPoint) -> ResolvePathResult {
+        ResolvePathResult::with(PerNs::none(), reached_fixedpoint, None)
+    }
+
+    fn with(
+        resolved_def: PerNs<ModuleDef>,
+        reached_fixedpoint: ReachedFixedPoint,
+        segment_index: Option<usize>,
+    ) -> ResolvePathResult {
+        ResolvePathResult { resolved_def, reached_fixedpoint, segment_index }
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum ResolveMode {
     Import,
@@ -468,8 +496,9 @@ impl ItemMap {
         db: &impl PersistentHirDatabase,
         original_module: Module,
         path: &Path,
-    ) -> PerNs<ModuleDef> {
-        self.resolve_path_fp(db, ResolveMode::Other, original_module, path).0
+    ) -> (PerNs<ModuleDef>, Option<usize>) {
+        let res = self.resolve_path_fp(db, ResolveMode::Other, original_module, path);
+        (res.resolved_def, res.segment_index)
     }
 
     fn resolve_in_prelude(
@@ -534,7 +563,7 @@ impl ItemMap {
         mode: ResolveMode,
         original_module: Module,
         path: &Path,
-    ) -> (PerNs<ModuleDef>, ReachedFixedPoint) {
+    ) -> ResolvePathResult {
         let mut segments = path.segments.iter().enumerate();
         let mut curr_per_ns: PerNs<ModuleDef> = match path.kind {
             PathKind::Crate => PerNs::types(original_module.crate_root(db).into()),
@@ -549,7 +578,7 @@ impl ItemMap {
             {
                 let segment = match segments.next() {
                     Some((_, segment)) => segment,
-                    None => return (PerNs::none(), ReachedFixedPoint::Yes),
+                    None => return ResolvePathResult::empty(ReachedFixedPoint::Yes),
                 };
                 log::debug!("resolving {:?} in crate root (+ extern prelude)", segment);
                 self.resolve_name_in_crate_root_or_extern_prelude(
@@ -561,7 +590,7 @@ impl ItemMap {
             PathKind::Plain => {
                 let segment = match segments.next() {
                     Some((_, segment)) => segment,
-                    None => return (PerNs::none(), ReachedFixedPoint::Yes),
+                    None => return ResolvePathResult::empty(ReachedFixedPoint::Yes),
                 };
                 log::debug!("resolving {:?} in module", segment);
                 self.resolve_name_in_module(db, original_module, &segment.name)
@@ -571,20 +600,20 @@ impl ItemMap {
                     PerNs::types(p.into())
                 } else {
                     log::debug!("super path in root module");
-                    return (PerNs::none(), ReachedFixedPoint::Yes);
+                    return ResolvePathResult::empty(ReachedFixedPoint::Yes);
                 }
             }
             PathKind::Abs => {
                 // 2018-style absolute path -- only extern prelude
                 let segment = match segments.next() {
                     Some((_, segment)) => segment,
-                    None => return (PerNs::none(), ReachedFixedPoint::Yes),
+                    None => return ResolvePathResult::empty(ReachedFixedPoint::Yes),
                 };
                 if let Some(def) = self.extern_prelude.get(&segment.name) {
                     log::debug!("absolute path {:?} resolved to crate {:?}", path, def);
                     PerNs::types(*def)
                 } else {
-                    return (PerNs::none(), ReachedFixedPoint::No); // extern crate declarations can add to the extern prelude
+                    return ResolvePathResult::empty(ReachedFixedPoint::No); // extern crate declarations can add to the extern prelude
                 }
             }
         };
@@ -598,7 +627,7 @@ impl ItemMap {
                     // (don't break here because `curr_per_ns` might contain
                     // something in the value namespace, and it would be wrong
                     // to return that)
-                    return (PerNs::none(), ReachedFixedPoint::No);
+                    return ResolvePathResult::empty(ReachedFixedPoint::No);
                 }
             };
             // resolve segment in curr
@@ -612,15 +641,15 @@ impl ItemMap {
                         };
                         log::debug!("resolving {:?} in other crate", path);
                         let item_map = db.item_map(module.krate);
-                        let def = item_map.resolve_path(db, *module, &path);
-                        return (def, ReachedFixedPoint::Yes);
+                        let (def, s) = item_map.resolve_path(db, *module, &path);
+                        return ResolvePathResult::with(def, ReachedFixedPoint::Yes, s);
                     }
 
                     match self[module.module_id].items.get(&segment.name) {
                         Some(res) if !res.def.is_none() => res.def,
                         _ => {
                             log::debug!("path segment {:?} not found", segment.name);
-                            return (PerNs::none(), ReachedFixedPoint::No);
+                            return ResolvePathResult::empty(ReachedFixedPoint::No);
                         }
                     }
                 }
@@ -629,23 +658,33 @@ impl ItemMap {
                     tested_by!(item_map_enum_importing);
                     match e.variant(db, &segment.name) {
                         Some(variant) => PerNs::both(variant.into(), variant.into()),
-                        None => PerNs::none(),
+                        None => {
+                            return ResolvePathResult::with(
+                                PerNs::types((*e).into()),
+                                ReachedFixedPoint::Yes,
+                                Some(i),
+                            );
+                        }
                     }
                 }
-                _ => {
+                s => {
                     // could be an inherent method call in UFCS form
-                    // (`Struct::method`), or some other kind of associated
-                    // item... Which we currently don't handle (TODO)
+                    // (`Struct::method`), or some other kind of associated item
                     log::debug!(
                         "path segment {:?} resolved to non-module {:?}, but is not last",
                         segment.name,
                         curr,
                     );
-                    return (PerNs::none(), ReachedFixedPoint::Yes);
+
+                    return ResolvePathResult::with(
+                        PerNs::types((*s).into()),
+                        ReachedFixedPoint::Yes,
+                        Some(i),
+                    );
                 }
             };
         }
-        (curr_per_ns, ReachedFixedPoint::Yes)
+        ResolvePathResult::with(curr_per_ns, ReachedFixedPoint::Yes, None)
     }
 }