Wrap remaining self/super/crate in Name{Ref}

[rust.git] / crates / ide_db / src / defs.rs

diff --git a/crates/ide_db/src/defs.rs b/crates/ide_db/src/defs.rs
index d33a6cb863ba256aad0fe1e7f6c7b797622e3f70..d9875ffef6a9f46bd77a448049d20bb47ef0b974 100644 (file)
--- a/crates/ide_db/src/defs.rs
+++ b/crates/ide_db/src/defs.rs
@@ -6,11 +6,11 @@
 // FIXME: this badly needs rename/rewrite (matklad, 2020-02-06).
 
 use hir::{
-    db::HirDatabase, Crate, Field, HasVisibility, Impl, Label, LifetimeParam, Local, MacroDef,
-    Module, ModuleDef, Name, PathResolution, Semantics, TypeParam, Visibility,
+    db::HirDatabase, Crate, Field, GenericParam, HasVisibility, Impl, Label, Local, MacroDef,
+    Module, ModuleDef, Name, PathResolution, Semantics, Visibility,
 };
 use syntax::{
-    ast::{self, AstNode},
+    ast::{self, AstNode, PathSegmentKind},
     match_ast, SyntaxKind, SyntaxNode,
 };
 
@@ -24,8 +24,7 @@ pub enum Definition {
     ModuleDef(ModuleDef),
     SelfType(Impl),
     Local(Local),
-    TypeParam(TypeParam),
-    LifetimeParam(LifetimeParam),
+    GenericParam(GenericParam),
     Label(Label),
 }
 
@@ -37,8 +36,7 @@ pub fn module(&self, db: &RootDatabase) -> Option<Module> {
             Definition::ModuleDef(it) => it.module(db),
             Definition::SelfType(it) => Some(it.module(db)),
             Definition::Local(it) => Some(it.module(db)),
-            Definition::TypeParam(it) => Some(it.module(db)),
-            Definition::LifetimeParam(it) => Some(it.module(db)),
+            Definition::GenericParam(it) => Some(it.module(db)),
             Definition::Label(it) => Some(it.module(db)),
         }
     }
@@ -50,8 +48,7 @@ pub fn visibility(&self, db: &RootDatabase) -> Option<Visibility> {
             Definition::ModuleDef(def) => def.definition_visibility(db),
             Definition::SelfType(_) => None,
             Definition::Local(_) => None,
-            Definition::TypeParam(_) => None,
-            Definition::LifetimeParam(_) => None,
+            Definition::GenericParam(_) => None,
             Definition::Label(_) => None,
         }
     }
@@ -77,8 +74,7 @@ pub fn name(&self, db: &RootDatabase) -> Option<Name> {
             },
             Definition::SelfType(_) => return None,
             Definition::Local(it) => it.name(db)?,
-            Definition::TypeParam(it) => it.name(db),
-            Definition::LifetimeParam(it) => it.name(db),
+            Definition::GenericParam(it) => it.name(db),
             Definition::Label(it) => it.name(db),
         };
         Some(name)
@@ -139,24 +135,26 @@ pub fn classify(sema: &Semantics<RootDatabase>, name: &ast::Name) -> Option<Name
                         let path = use_tree.path()?;
                         let path_segment = path.segment()?;
                         let name_ref_class = path_segment
-                            .name_ref()
-                            // The rename might be from a `self` token, so fallback to the name higher
-                            // in the use tree.
-                            .or_else(||{
-                                if path_segment.self_token().is_none() {
-                                    return None;
+                            .kind()
+                            .and_then(|kind| {
+                                match kind {
+                                    // The rename might be from a `self` token, so fallback to the name higher
+                                    // in the use tree.
+                                    PathSegmentKind::SelfKw => {
+                                        let use_tree = use_tree
+                                            .syntax()
+                                            .parent()
+                                            .as_ref()
+                                            // Skip over UseTreeList
+                                            .and_then(SyntaxNode::parent)
+                                            .and_then(ast::UseTree::cast)?;
+                                        let path = use_tree.path()?;
+                                        let path_segment = path.segment()?;
+                                        path_segment.name_ref()
+                                    },
+                                    PathSegmentKind::Name(name_ref) => Some(name_ref),
+                                    _ => return None,
                                 }
-
-                                let use_tree = use_tree
-                                    .syntax()
-                                    .parent()
-                                    .as_ref()
-                                    // Skip over UseTreeList
-                                    .and_then(SyntaxNode::parent)
-                                    .and_then(ast::UseTree::cast)?;
-                                let path = use_tree.path()?;
-                                let path_segment = path.segment()?;
-                                path_segment.name_ref()
                             })
                             .and_then(|name_ref| NameRefClass::classify(sema, &name_ref))?;
 
@@ -181,6 +179,10 @@ pub fn classify(sema: &Semantics<RootDatabase>, name: &ast::Name) -> Option<Name
 
                     Some(NameClass::Definition(Definition::Local(local)))
                 },
+                ast::SelfParam(it) => {
+                    let def = sema.to_def(&it)?;
+                    Some(NameClass::Definition(Definition::Local(def.into())))
+                },
                 ast::RecordField(it) => {
                     let field: hir::Field = sema.to_def(&it)?;
                     Some(NameClass::Definition(Definition::Field(field)))
@@ -231,7 +233,11 @@ pub fn classify(sema: &Semantics<RootDatabase>, name: &ast::Name) -> Option<Name
                 },
                 ast::TypeParam(it) => {
                     let def = sema.to_def(&it)?;
-                    Some(NameClass::Definition(Definition::TypeParam(def)))
+                    Some(NameClass::Definition(Definition::GenericParam(def.into())))
+                },
+                ast::ConstParam(it) => {
+                    let def = sema.to_def(&it)?;
+                    Some(NameClass::Definition(Definition::GenericParam(def.into())))
                 },
                 _ => None,
             }
@@ -249,7 +255,7 @@ pub fn classify_lifetime(
             match parent {
                 ast::LifetimeParam(it) => {
                     let def = sema.to_def(&it)?;
-                    Some(NameClass::Definition(Definition::LifetimeParam(def)))
+                    Some(NameClass::Definition(Definition::GenericParam(def.into())))
                 },
                 ast::Label(it) => {
                     let def = sema.to_def(&it)?;
@@ -350,7 +356,7 @@ pub fn classify(
             if let Some(path) = macro_call.path() {
                 if path.qualifier().is_none() {
                     // Only use this to resolve single-segment macro calls like `foo!()`. Multi-segment
-                    // paths are handled below (allowing `log<|>::info!` to resolve to the log crate).
+                    // paths are handled below (allowing `log$0::info!` to resolve to the log crate).
                     if let Some(macro_def) = sema.resolve_macro_call(&macro_call) {
                         return Some(NameRefClass::Definition(Definition::Macro(macro_def)));
                     }
@@ -385,7 +391,8 @@ pub fn classify_lifetime(
             | SyntaxKind::WHERE_PRED
             | SyntaxKind::REF_TYPE => sema
                 .resolve_lifetime_param(lifetime)
-                .map(Definition::LifetimeParam)
+                .map(GenericParam::LifetimeParam)
+                .map(Definition::GenericParam)
                 .map(NameRefClass::Definition),
             // lifetime bounds, as in the 'b in 'a: 'b aren't wrapped in TypeBound nodes so we gotta check
             // if our lifetime is in a LifetimeParam without being the constrained lifetime
@@ -393,7 +400,8 @@ pub fn classify_lifetime(
                 != Some(lifetime) =>
             {
                 sema.resolve_lifetime_param(lifetime)
-                    .map(Definition::LifetimeParam)
+                    .map(GenericParam::LifetimeParam)
+                    .map(Definition::GenericParam)
                     .map(NameRefClass::Definition)
             }
             _ => None,
@@ -414,9 +422,10 @@ fn from(path_resolution: PathResolution) -> Self {
                 Definition::ModuleDef(def)
             }
             PathResolution::Local(local) => Definition::Local(local),
-            PathResolution::TypeParam(par) => Definition::TypeParam(par),
+            PathResolution::TypeParam(par) => Definition::GenericParam(par.into()),
             PathResolution::Macro(def) => Definition::Macro(def),
             PathResolution::SelfType(impl_def) => Definition::SelfType(impl_def),
+            PathResolution::ConstParam(par) => Definition::GenericParam(par.into()),
         }
     }
 }