Use hir::GenericParam in ide_db::Definition instead of relisting all 3

Veykril · Veykril · commit b795128dde24 · 2021-01-10T12:33:47.000+01:00
diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs
@@ -1263,6 +1263,24 @@ pub enum GenericParam {
 }
 impl_from!(TypeParam, LifetimeParam, ConstParam for GenericParam);
 
+impl GenericParam {
+    pub fn module(self, db: &dyn HirDatabase) -> Module {
+        match self {
+            GenericParam::TypeParam(it) => it.module(db),
+            GenericParam::LifetimeParam(it) => it.module(db),
+            GenericParam::ConstParam(it) => it.module(db),
+        }
+    }
+
+    pub fn name(self, db: &dyn HirDatabase) -> Name {
+        match self {
+            GenericParam::TypeParam(it) => it.name(db),
+            GenericParam::LifetimeParam(it) => it.name(db),
+            GenericParam::ConstParam(it) => it.name(db),
+        }
+    }
+}
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub struct TypeParam {
     pub(crate) id: TypeParamId,
diff --git a/crates/ide/src/display/navigation_target.rs b/crates/ide/src/display/navigation_target.rs
@@ -215,10 +215,8 @@ impl TryToNav for Definition {
             Definition::ModuleDef(it) => it.try_to_nav(db),
             Definition::SelfType(it) => it.try_to_nav(db),
             Definition::Local(it) => Some(it.to_nav(db)),
-            Definition::TypeParam(it) => it.try_to_nav(db),
-            Definition::LifetimeParam(it) => it.try_to_nav(db),
+            Definition::GenericParam(it) => it.try_to_nav(db),
             Definition::Label(it) => Some(it.to_nav(db)),
-            Definition::ConstParam(it) => it.try_to_nav(db),
         }
     }
 }
@@ -389,6 +387,16 @@ impl TryToNav for hir::AssocItem {
     }
 }
 
+impl TryToNav for hir::GenericParam {
+    fn try_to_nav(&self, db: &RootDatabase) -> Option<NavigationTarget> {
+        match self {
+            hir::GenericParam::TypeParam(it) => it.try_to_nav(db),
+            hir::GenericParam::ConstParam(it) => it.try_to_nav(db),
+            hir::GenericParam::LifetimeParam(it) => it.try_to_nav(db),
+        }
+    }
+}
+
 impl ToNav for hir::Local {
     fn to_nav(&self, db: &RootDatabase) -> NavigationTarget {
         let src = self.source(db);
diff --git a/crates/ide/src/doc_links.rs b/crates/ide/src/doc_links.rs
@@ -216,9 +216,7 @@ fn rewrite_intra_doc_link(
         Definition::Field(it) => it.resolve_doc_path(db, link, ns),
         Definition::SelfType(_)
         | Definition::Local(_)
-        | Definition::TypeParam(_)
-        | Definition::ConstParam(_)
-        | Definition::LifetimeParam(_)
+        | Definition::GenericParam(_)
         | Definition::Label(_) => return None,
     }?;
     let krate = resolved.module(db)?.krate();
diff --git a/crates/ide/src/goto_definition.rs b/crates/ide/src/goto_definition.rs
@@ -111,9 +111,7 @@ fn def_for_doc_comment(
         Definition::Field(it) => it.resolve_doc_path(db, link, ns),
         Definition::SelfType(_)
         | Definition::Local(_)
-        | Definition::TypeParam(_)
-        | Definition::LifetimeParam(_)
-        | Definition::ConstParam(_)
+        | Definition::GenericParam(_)
         | Definition::Label(_) => return None,
     }
 }
diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs
@@ -1,6 +1,6 @@
 use hir::{
-    Adt, AsAssocItem, AssocItemContainer, FieldSource, HasAttrs, HasSource, HirDisplay, Module,
-    ModuleDef, ModuleSource, Semantics,
+    Adt, AsAssocItem, AssocItemContainer, FieldSource, GenericParam, HasAttrs, HasSource,
+    HirDisplay, Module, ModuleDef, ModuleSource, Semantics,
 };
 use ide_db::base_db::SourceDatabase;
 use ide_db::{
@@ -220,12 +220,12 @@ fn goto_type_action(db: &RootDatabase, def: Definition) -> Option<HoverAction> {
         }
     };
 
-    if let Definition::TypeParam(it) = def {
+    if let Definition::GenericParam(GenericParam::TypeParam(it)) = def {
         it.trait_bounds(db).into_iter().for_each(|it| push_new_def(it.into()));
     } else {
         let ty = match def {
             Definition::Local(it) => it.ty(db),
-            Definition::ConstParam(it) => it.ty(db),
+            Definition::GenericParam(GenericParam::ConstParam(it)) => it.ty(db),
             _ => return None,
         };
 
@@ -357,9 +357,11 @@ fn hover_for_definition(db: &RootDatabase, def: Definition) -> Option<Markup> {
             })
         }
         Definition::Label(it) => Some(Markup::fenced_block(&it.name(db))),
-        Definition::LifetimeParam(it) => Some(Markup::fenced_block(&it.name(db))),
-        Definition::TypeParam(type_param) => Some(Markup::fenced_block(&type_param.display(db))),
-        Definition::ConstParam(it) => from_def_source(db, it, None),
+        Definition::GenericParam(it) => match it {
+            GenericParam::TypeParam(it) => Some(Markup::fenced_block(&it.display(db))),
+            GenericParam::LifetimeParam(it) => Some(Markup::fenced_block(&it.name(db))),
+            GenericParam::ConstParam(it) => from_def_source(db, it, None),
+        },
     };
 
     fn from_def_source<A, D>(db: &RootDatabase, def: D, mod_path: Option<String>) -> Option<Markup>
diff --git a/crates/ide/src/references.rs b/crates/ide/src/references.rs
@@ -130,7 +130,10 @@ pub(crate) fn find_all_refs(
                 kind = ReferenceKind::FieldShorthandForLocal;
             }
         }
-    } else if matches!(def, Definition::LifetimeParam(_) | Definition::Label(_)) {
+    } else if matches!(
+        def,
+        Definition::GenericParam(hir::GenericParam::LifetimeParam(_)) | Definition::Label(_)
+    ) {
         kind = ReferenceKind::Lifetime;
     };
 
diff --git a/crates/ide/src/syntax_highlighting/highlight.rs b/crates/ide/src/syntax_highlighting/highlight.rs
@@ -328,8 +328,11 @@ fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
             }
         },
         Definition::SelfType(_) => HlTag::Symbol(SymbolKind::Impl),
-        Definition::TypeParam(_) => HlTag::Symbol(SymbolKind::TypeParam),
-        Definition::ConstParam(_) => HlTag::Symbol(SymbolKind::ConstParam),
+        Definition::GenericParam(it) => match it {
+            hir::GenericParam::TypeParam(_) => HlTag::Symbol(SymbolKind::TypeParam),
+            hir::GenericParam::ConstParam(_) => HlTag::Symbol(SymbolKind::ConstParam),
+            hir::GenericParam::LifetimeParam(_) => HlTag::Symbol(SymbolKind::LifetimeParam),
+        },
         Definition::Local(local) => {
             let tag = if local.is_param(db) {
                 HlTag::Symbol(SymbolKind::ValueParam)
@@ -345,7 +348,6 @@ fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
             }
             return h;
         }
-        Definition::LifetimeParam(_) => HlTag::Symbol(SymbolKind::LifetimeParam),
         Definition::Label(_) => HlTag::Symbol(SymbolKind::Label),
     }
     .into()
diff --git a/crates/ide_db/src/defs.rs b/crates/ide_db/src/defs.rs
@@ -6,8 +6,8 @@
 // FIXME: this badly needs rename/rewrite (matklad, 2020-02-06).
 
 use hir::{
-    db::HirDatabase, ConstParam, 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},
@@ -24,9 +24,7 @@ pub enum Definition {
     ModuleDef(ModuleDef),
     SelfType(Impl),
     Local(Local),
-    TypeParam(TypeParam),
-    LifetimeParam(LifetimeParam),
-    ConstParam(ConstParam),
+    GenericParam(GenericParam),
     Label(Label),
 }
 
@@ -38,9 +36,7 @@ impl Definition {
             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::ConstParam(it) => Some(it.module(db)),
+            Definition::GenericParam(it) => Some(it.module(db)),
             Definition::Label(it) => Some(it.module(db)),
         }
     }
@@ -52,9 +48,7 @@ impl Definition {
             Definition::ModuleDef(def) => def.definition_visibility(db),
             Definition::SelfType(_) => None,
             Definition::Local(_) => None,
-            Definition::TypeParam(_) => None,
-            Definition::LifetimeParam(_) => None,
-            Definition::ConstParam(_) => None,
+            Definition::GenericParam(_) => None,
             Definition::Label(_) => None,
         }
     }
@@ -80,9 +74,7 @@ impl Definition {
             },
             Definition::SelfType(_) => return None,
             Definition::Local(it) => it.name(db)?,
-            Definition::TypeParam(it) => it.name(db),
-            Definition::LifetimeParam(it) => it.name(db),
-            Definition::ConstParam(it) => it.name(db),
+            Definition::GenericParam(it) => it.name(db),
             Definition::Label(it) => it.name(db),
         };
         Some(name)
@@ -235,11 +227,11 @@ impl NameClass {
                 },
                 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::ConstParam(def)))
+                    Some(NameClass::Definition(Definition::GenericParam(def.into())))
                 },
                 _ => None,
             }
@@ -257,7 +249,7 @@ impl NameClass {
             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)?;
@@ -393,15 +385,17 @@ impl NameRefClass {
             | 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
             _ if ast::LifetimeParam::cast(parent).and_then(|param| param.lifetime()).as_ref()
                 != Some(lifetime) =>
             {
                 sema.resolve_lifetime_param(lifetime)
-                    .map(Definition::LifetimeParam)
+                    .map(GenericParam::LifetimeParam)
+                    .map(Definition::GenericParam)
                     .map(NameRefClass::Definition)
             }
             _ => None,
@@ -422,10 +416,10 @@ impl From<PathResolution> for Definition {
                 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::ConstParam(par),
+            PathResolution::ConstParam(par) => Definition::GenericParam(par.into()),
         }
     }
 }
diff --git a/crates/ide_db/src/search.rs b/crates/ide_db/src/search.rs
@@ -136,7 +136,7 @@ impl Definition {
             return SearchScope::new(res);
         }
 
-        if let Definition::LifetimeParam(param) = self {
+        if let Definition::GenericParam(hir::GenericParam::LifetimeParam(param)) = self {
             let range = match param.parent(db) {
                 hir::GenericDef::Function(it) => {
                     it.source(db).and_then(|src| Some(src.value.syntax().text_range()))

Original file line number	Diff line number	Diff line change
`@@ -215,10 +215,8 @@ impl TryToNav for Definition {`
`215`	`215`	`Definition::ModuleDef(it) => it.try_to_nav(db),`
`216`	`216`	`Definition::SelfType(it) => it.try_to_nav(db),`
`217`	`217`	`Definition::Local(it) => Some(it.to_nav(db)),`
`218`		`- Definition::TypeParam(it) => it.try_to_nav(db),`
`219`		`- Definition::LifetimeParam(it) => it.try_to_nav(db),`
	`218`	`+ Definition::GenericParam(it) => it.try_to_nav(db),`
`220`	`219`	`Definition::Label(it) => Some(it.to_nav(db)),`
`221`		`- Definition::ConstParam(it) => it.try_to_nav(db),`
`222`	`220`	`}`
`223`	`221`	`}`
`224`	`222`	`}`
`@@ -389,6 +387,16 @@ impl TryToNav for hir::AssocItem {`
`389`	`387`	`}`
`390`	`388`	`}`
`391`	`389`
	`390`	`+impl TryToNav for hir::GenericParam {`
	`391`	`+ fn try_to_nav(&self, db: &RootDatabase) -> Option<NavigationTarget> {`
	`392`	`+ match self {`
	`393`	`+ hir::GenericParam::TypeParam(it) => it.try_to_nav(db),`
	`394`	`+ hir::GenericParam::ConstParam(it) => it.try_to_nav(db),`
	`395`	`+ hir::GenericParam::LifetimeParam(it) => it.try_to_nav(db),`
	`396`	`+ }`
	`397`	`+ }`
	`398`	`+}`
	`399`	`+`
`392`	`400`	`impl ToNav for hir::Local {`
`393`	`401`	`fn to_nav(&self, db: &RootDatabase) -> NavigationTarget {`
`394`	`402`	`let src = self.source(db);`
Original file line number	Diff line number	Diff line change
`@@ -111,9 +111,7 @@ fn def_for_doc_comment(`
`111`	`111`	`Definition::Field(it) => it.resolve_doc_path(db, link, ns),`
`112`	`112`	`Definition::SelfType(_)`
`113`	`113`	`\| Definition::Local(_)`
`114`		`- \| Definition::TypeParam(_)`
`115`		`- \| Definition::LifetimeParam(_)`
`116`		`- \| Definition::ConstParam(_)`
	`114`	`+ \| Definition::GenericParam(_)`
`117`	`115`	`\| Definition::Label(_) => return None,`
`118`	`116`	`}`
`119`	`117`	`}`
Original file line number	Diff line number	Diff line change
`@@ -130,7 +130,10 @@ pub(crate) fn find_all_refs(`
`130`	`130`	`kind = ReferenceKind::FieldShorthandForLocal;`
`131`	`131`	`}`
`132`	`132`	`}`
`133`		`- } else if matches!(def, Definition::LifetimeParam(_) \| Definition::Label(_)) {`
	`133`	`+ } else if matches!(`
	`134`	`+ def,`
	`135`	`+ Definition::GenericParam(hir::GenericParam::LifetimeParam(_)) \| Definition::Label(_)`
	`136`	`+ ) {`
`134`	`137`	`kind = ReferenceKind::Lifetime;`
`135`	`138`	`};`
`136`	`139`
Original file line number	Diff line number	Diff line change
`@@ -328,8 +328,11 @@ fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {`
`328`	`328`	`}`
`329`	`329`	`},`
`330`	`330`	`Definition::SelfType(_) => HlTag::Symbol(SymbolKind::Impl),`
`331`		`- Definition::TypeParam(_) => HlTag::Symbol(SymbolKind::TypeParam),`
`332`		`- Definition::ConstParam(_) => HlTag::Symbol(SymbolKind::ConstParam),`
	`331`	`+ Definition::GenericParam(it) => match it {`
	`332`	`+ hir::GenericParam::TypeParam(_) => HlTag::Symbol(SymbolKind::TypeParam),`
	`333`	`+ hir::GenericParam::ConstParam(_) => HlTag::Symbol(SymbolKind::ConstParam),`
	`334`	`+ hir::GenericParam::LifetimeParam(_) => HlTag::Symbol(SymbolKind::LifetimeParam),`
	`335`	`+ },`
`333`	`336`	`Definition::Local(local) => {`
`334`	`337`	`let tag = if local.is_param(db) {`
`335`	`338`	`HlTag::Symbol(SymbolKind::ValueParam)`
`@@ -345,7 +348,6 @@ fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {`
`345`	`348`	`}`
`346`	`349`	`return h;`
`347`	`350`	`}`
`348`		`- Definition::LifetimeParam(_) => HlTag::Symbol(SymbolKind::LifetimeParam),`
`349`	`351`	`Definition::Label(_) => HlTag::Symbol(SymbolKind::Label),`
`350`	`352`	`}`
`351`	`353`	`.into()`
Original file line number	Diff line number	Diff line change
`@@ -136,7 +136,7 @@ impl Definition {`
`136`	`136`	`return SearchScope::new(res);`
`137`	`137`	`}`
`138`	`138`
`139`		`- if let Definition::LifetimeParam(param) = self {`
	`139`	`+ if let Definition::GenericParam(hir::GenericParam::LifetimeParam(param)) = self {`
`140`	`140`	`let range = match param.parent(db) {`
`141`	`141`	`hir::GenericDef::Function(it) => {`
`142`	`142`	`it.source(db).and_then(\|src\| Some(src.value.syntax().text_range()))`