Change resolve_path to return the fully resolved path or PerNs::none

This also adds new pub(crate) resolve_path_segments which returns the
PathResult, which may or may not be fully resolved. PathResult is also now
pub(crate) since it is an implementation detail.

3 files changed, 36 insertions, 34 deletions

diff --git a/crates/ra_hir/src/impl_block.rs b/crates/ra_hir/src/impl_block.rs
index f4dccf165..7ecf8c368 100644
--- a/crates/ra_hir/src/impl_block.rs
+++ b/crates/ra_hir/src/impl_block.rs
@@ -88,7 +88,7 @@ impl ImplBlock {
         if let Some(TypeRef::Path(path)) = self.target_trait_ref(db) {
             let resolver = self.resolver(db);
             if let Some(Resolution::Def(ModuleDef::Trait(tr))) =
-                resolver.resolve_path(db, &path).into_per_ns().take_types()
+                resolver.resolve_path(db, &path).take_types()
             {
                 return Some(tr);
             }
diff --git a/crates/ra_hir/src/resolve.rs b/crates/ra_hir/src/resolve.rs
index 9f4d4ab42..57e7d0b9a 100644
--- a/crates/ra_hir/src/resolve.rs
+++ b/crates/ra_hir/src/resolve.rs
@@ -33,7 +33,7 @@ pub(crate) struct ExprScope {
 }
 
 #[derive(Debug, Clone)]
-pub struct PathResult {
+pub(crate) struct PathResult {
     /// The actual path resolution
     resolution: PerNs<Resolution>,
     /// The first index in the path that we
@@ -45,7 +45,7 @@ pub struct PathResult {
 impl PathResult {
     /// Returns the remaining index in the result
     /// returns None if the path was fully resolved
-    pub fn remaining_index(&self) -> Option<usize> {
+    pub(crate) fn remaining_index(&self) -> Option<usize> {
         if self.remaining_index > 0 {
             Some(self.remaining_index)
         } else {
@@ -55,8 +55,8 @@ impl PathResult {
 
     /// Consumes `PathResult` and returns the contained `PerNs<Resolution>`
     /// if the path was fully resolved, meaning we have no remaining items
-    pub fn into_per_ns(self) -> PerNs<Resolution> {
-        if self.remaining_index().is_none() {
+    pub(crate) fn into_fully_resolved(self) -> PerNs<Resolution> {
+        if self.is_fully_resolved() {
             self.resolution
         } else {
             PerNs::none()
@@ -65,23 +65,17 @@ impl PathResult {
 
     /// Consumes `PathResult` and returns the resolution and the
     /// remaining_index as a tuple.
-    pub fn into_inner(self) -> (PerNs<Resolution>, Option<usize>) {
+    pub(crate) fn into_inner(self) -> (PerNs<Resolution>, Option<usize>) {
         let index = self.remaining_index();
         (self.resolution, index)
     }
 
     /// Path is fully resolved when `remaining_index` is none
     /// and the resolution contains anything
-    pub fn is_fully_resolved(&self) -> bool {
+    pub(crate) fn is_fully_resolved(&self) -> bool {
         !self.resolution.is_none() && self.remaining_index().is_none()
     }
 
-    /// Empty path result is where the resolution is `none`
-    /// and the remaining index is 0
-    pub fn is_empty(&self) -> bool {
-        self.resolution.is_none() && self.remaining_index().is_none()
-    }
-
     fn empty() -> PathResult {
         PathResult { resolution: PerNs::none(), remaining_index: 0 }
     }
@@ -134,7 +128,9 @@ impl Resolver {
         resolution
     }
 
-    pub fn resolve_path(&self, db: &impl HirDatabase, path: &Path) -> PathResult {
+    /// Returns the resolved path segments
+    /// Which may be fully resolved, empty or partially resolved.
+    pub(crate) fn resolve_path_segments(&self, db: &impl HirDatabase, path: &Path) -> PathResult {
         if let Some(name) = path.as_ident() {
             PathResult::from_resolution(self.resolve_name(db, name))
         } else if path.is_self() {
@@ -156,6 +152,13 @@ impl Resolver {
         }
     }
 
+    /// Returns the fully resolved path if we were able to resolve it.
+    /// otherwise returns `PerNs::none`
+    pub fn resolve_path(&self, db: &impl HirDatabase, path: &Path) -> PerNs<Resolution> {
+        // into_fully_resolved() returns the fully resolved path or PerNs::none() otherwise
+        self.resolve_path_segments(db, path).into_fully_resolved()
+    }
+
     pub fn all_names(&self, db: &impl HirDatabase) -> FxHashMap<Name, PerNs<Resolution>> {
         let mut names = FxHashMap::default();
         for scope in self.scopes.iter().rev() {
diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
index b1f35ab1f..89e854dd7 100644
--- a/crates/ra_hir/src/ty.rs
+++ b/crates/ra_hir/src/ty.rs
@@ -370,7 +370,7 @@ impl Ty {
         }
 
         // Resolve the path (in type namespace)
-        let resolution = resolver.resolve_path(db, path).into_per_ns().take_types();
+        let resolution = resolver.resolve_path(db, path).take_types();
 
         let def = match resolution {
             Some(Resolution::Def(def)) => def,
@@ -1172,7 +1172,7 @@ 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);
+        let resolved = resolver.resolve_path_segments(self.db, &path);
 
         let (def, remaining_index) = resolved.into_inner();
 
@@ -1244,24 +1244,23 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             None => return (Ty::Unknown, None),
         };
         let resolver = &self.resolver;
-        let typable: Option<TypableDef> =
-            match resolver.resolve_path(self.db, &path).into_per_ns().take_types() {
-                Some(Resolution::Def(def)) => def.into(),
-                Some(Resolution::LocalBinding(..)) => {
-                    // this cannot happen
-                    log::error!("path resolved to local binding in type ns");
-                    return (Ty::Unknown, None);
-                }
-                Some(Resolution::GenericParam(..)) => {
-                    // generic params can't be used in struct literals
-                    return (Ty::Unknown, None);
-                }
-                Some(Resolution::SelfType(..)) => {
-                    // TODO this is allowed in an impl for a struct, handle this
-                    return (Ty::Unknown, None);
-                }
-                None => return (Ty::Unknown, None),
-            };
+        let typable: Option<TypableDef> = match resolver.resolve_path(self.db, &path).take_types() {
+            Some(Resolution::Def(def)) => def.into(),
+            Some(Resolution::LocalBinding(..)) => {
+                // this cannot happen
+                log::error!("path resolved to local binding in type ns");
+                return (Ty::Unknown, None);
+            }
+            Some(Resolution::GenericParam(..)) => {
+                // generic params can't be used in struct literals
+                return (Ty::Unknown, None);
+            }
+            Some(Resolution::SelfType(..)) => {
+                // TODO this is allowed in an impl for a struct, handle this
+                return (Ty::Unknown, None);
+            }
+            None => return (Ty::Unknown, None),
+        };
         let def = match typable {
             None => return (Ty::Unknown, None),
             Some(it) => it,