Merge #2561

2561: Split generic and non-generic paths r=matklad a=matklad



Co-authored-by: Aleksey Kladov <[email protected]>

2 files changed, 30 insertions, 28 deletions

diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index e7602ee30..451b227a6 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -54,7 +54,7 @@ pub use hir_def::{
     builtin_type::BuiltinType,
     docs::Documentation,
     nameres::ModuleSource,
-    path::{Path, PathKind},
+    path::{ModPath, Path, PathKind},
     type_ref::Mutability,
 };
 pub use hir_expand::{
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index f82242c3a..d326169b3 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -258,7 +258,7 @@ impl SourceAnalyzer {
     ) -> Option<MacroDef> {
         let hygiene = Hygiene::new(db, macro_call.file_id);
         let path = macro_call.value.path().and_then(|ast| Path::from_src(ast, &hygiene))?;
-        self.resolver.resolve_path_as_macro(db, &path).map(|it| it.into())
+        self.resolver.resolve_path_as_macro(db, path.mod_path()).map(|it| it.into())
     }
 
     pub fn resolve_hir_path(
@@ -266,40 +266,42 @@ impl SourceAnalyzer {
         db: &impl HirDatabase,
         path: &crate::Path,
     ) -> Option<PathResolution> {
-        let types = self.resolver.resolve_path_in_type_ns_fully(db, &path).map(|ty| match ty {
-            TypeNs::SelfType(it) => PathResolution::SelfType(it.into()),
-            TypeNs::GenericParam(id) => PathResolution::TypeParam(TypeParam { id }),
-            TypeNs::AdtSelfType(it) | TypeNs::AdtId(it) => {
-                PathResolution::Def(Adt::from(it).into())
-            }
-            TypeNs::EnumVariantId(it) => PathResolution::Def(EnumVariant::from(it).into()),
-            TypeNs::TypeAliasId(it) => PathResolution::Def(TypeAlias::from(it).into()),
-            TypeNs::BuiltinType(it) => PathResolution::Def(it.into()),
-            TypeNs::TraitId(it) => PathResolution::Def(Trait::from(it).into()),
-        });
-        let values = self.resolver.resolve_path_in_value_ns_fully(db, &path).and_then(|val| {
-            let res = match val {
-                ValueNs::LocalBinding(pat_id) => {
-                    let var = Local { parent: self.body_owner?, pat_id };
-                    PathResolution::Local(var)
+        let types =
+            self.resolver.resolve_path_in_type_ns_fully(db, path.mod_path()).map(|ty| match ty {
+                TypeNs::SelfType(it) => PathResolution::SelfType(it.into()),
+                TypeNs::GenericParam(id) => PathResolution::TypeParam(TypeParam { id }),
+                TypeNs::AdtSelfType(it) | TypeNs::AdtId(it) => {
+                    PathResolution::Def(Adt::from(it).into())
                 }
-                ValueNs::FunctionId(it) => PathResolution::Def(Function::from(it).into()),
-                ValueNs::ConstId(it) => PathResolution::Def(Const::from(it).into()),
-                ValueNs::StaticId(it) => PathResolution::Def(Static::from(it).into()),
-                ValueNs::StructId(it) => PathResolution::Def(Struct::from(it).into()),
-                ValueNs::EnumVariantId(it) => PathResolution::Def(EnumVariant::from(it).into()),
-            };
-            Some(res)
-        });
+                TypeNs::EnumVariantId(it) => PathResolution::Def(EnumVariant::from(it).into()),
+                TypeNs::TypeAliasId(it) => PathResolution::Def(TypeAlias::from(it).into()),
+                TypeNs::BuiltinType(it) => PathResolution::Def(it.into()),
+                TypeNs::TraitId(it) => PathResolution::Def(Trait::from(it).into()),
+            });
+        let values =
+            self.resolver.resolve_path_in_value_ns_fully(db, path.mod_path()).and_then(|val| {
+                let res = match val {
+                    ValueNs::LocalBinding(pat_id) => {
+                        let var = Local { parent: self.body_owner?, pat_id };
+                        PathResolution::Local(var)
+                    }
+                    ValueNs::FunctionId(it) => PathResolution::Def(Function::from(it).into()),
+                    ValueNs::ConstId(it) => PathResolution::Def(Const::from(it).into()),
+                    ValueNs::StaticId(it) => PathResolution::Def(Static::from(it).into()),
+                    ValueNs::StructId(it) => PathResolution::Def(Struct::from(it).into()),
+                    ValueNs::EnumVariantId(it) => PathResolution::Def(EnumVariant::from(it).into()),
+                };
+                Some(res)
+            });
 
         let items = self
             .resolver
-            .resolve_module_path_in_items(db, &path)
+            .resolve_module_path_in_items(db, path.mod_path())
             .take_types()
             .map(|it| PathResolution::Def(it.into()));
         types.or(values).or(items).or_else(|| {
             self.resolver
-                .resolve_path_as_macro(db, &path)
+                .resolve_path_as_macro(db, path.mod_path())
                 .map(|def| PathResolution::Macro(def.into()))
         })
     }