14 files changed, 125 insertions, 94 deletions

diff --git a/crates/completion/src/completions/attribute.rs b/crates/completion/src/completions/attribute.rs
index 3a29b5203..a52ca107e 100644
--- a/crates/completion/src/completions/attribute.rs
+++ b/crates/completion/src/completions/attribute.rs
@@ -21,15 +21,17 @@ pub(crate) fn complete_attribute(acc: &mut Completions, ctx: &CompletionContext)
 
     let attribute = ctx.attribute_under_caret.as_ref()?;
     match (attribute.path(), attribute.token_tree()) {
-        (Some(path), Some(token_tree)) => match path.to_string().as_str() {
-            "derive" => complete_derive(acc, ctx, token_tree),
-            "feature" => complete_lint(acc, ctx, token_tree, FEATURES),
-            "allow" | "warn" | "deny" | "forbid" => {
+        (Some(path), Some(token_tree)) => {
+            let path = path.syntax().text();
+            if path == "derive" {
+                complete_derive(acc, ctx, token_tree)
+            } else if path == "feature" {
+                complete_lint(acc, ctx, token_tree, FEATURES)
+            } else if path == "allow" || path == "warn" || path == "deny" || path == "forbid" {
                 complete_lint(acc, ctx, token_tree.clone(), DEFAULT_LINT_COMPLETIONS);
                 complete_lint(acc, ctx, token_tree, CLIPPY_LINTS);
             }
-            _ => {}
-        },
+        }
         (_, Some(_token_tree)) => {}
         _ => complete_attribute_start(acc, ctx, attribute),
     }
diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index cc1938333..6cbf5cecf 100644
--- 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
index e24c78301..4eecae697 100644
--- 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
index 678d22d03..91f4241f9 100644
--- 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
index 227f20943..c20185b16 100644
--- 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
index 8cb4a51d8..e331f8886 100644
--- 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::{
@@ -17,7 +17,7 @@ use crate::{
     doc_links::{remove_links, rewrite_links},
     markdown_remove::remove_markdown,
     markup::Markup,
-    runnables::{runnable, runnable_fn},
+    runnables::{runnable_fn, runnable_mod},
     FileId, FilePosition, NavigationTarget, RangeInfo, Runnable,
 };
 
@@ -192,7 +192,7 @@ fn runnable_action(
         Definition::ModuleDef(it) => match it {
             ModuleDef::Module(it) => match it.definition_source(sema.db).value {
                 ModuleSource::Module(it) => {
-                    runnable(&sema, it.syntax().clone()).map(|it| HoverAction::Runnable(it))
+                    runnable_mod(&sema, it).map(|it| HoverAction::Runnable(it))
                 }
                 _ => None,
             },
@@ -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
index c95ed669c..0d5cd5f9a 100644
--- 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/runnables.rs b/crates/ide/src/runnables.rs
index 557563d7e..3a1e204db 100644
--- a/crates/ide/src/runnables.rs
+++ b/crates/ide/src/runnables.rs
@@ -96,21 +96,23 @@ impl Runnable {
 pub(crate) fn runnables(db: &RootDatabase, file_id: FileId) -> Vec<Runnable> {
     let sema = Semantics::new(db);
     let source_file = sema.parse(file_id);
-    source_file.syntax().descendants().filter_map(|i| runnable(&sema, i)).collect()
-}
-
-pub(crate) fn runnable(sema: &Semantics<RootDatabase>, item: SyntaxNode) -> Option<Runnable> {
-    let runnable_item = match_ast! {
-        match (item.clone()) {
-            ast::Fn(func) => {
-                let def = sema.to_def(&func)?;
-                runnable_fn(sema, def)
-            },
-            ast::Module(it) => runnable_mod(sema, it),
-            _ => None,
-        }
-    };
-    runnable_item.or_else(|| runnable_doctest(sema, item))
+    source_file
+        .syntax()
+        .descendants()
+        .filter_map(|item| {
+            let runnable = match_ast! {
+                match item {
+                    ast::Fn(func) => {
+                        let def = sema.to_def(&func)?;
+                        runnable_fn(&sema, def)
+                    },
+                    ast::Module(it) => runnable_mod(&sema, it),
+                    _ => None,
+                }
+            };
+            runnable.or_else(|| runnable_doctest(&sema, item))
+        })
+        .collect()
 }
 
 pub(crate) fn runnable_fn(sema: &Semantics<RootDatabase>, def: hir::Function) -> Option<Runnable> {
@@ -145,6 +147,29 @@ pub(crate) fn runnable_fn(sema: &Semantics<RootDatabase>, def: hir::Function) ->
     Some(Runnable { nav, kind, cfg })
 }
 
+pub(crate) fn runnable_mod(
+    sema: &Semantics<RootDatabase>,
+    module: ast::Module,
+) -> Option<Runnable> {
+    if !has_test_function_or_multiple_test_submodules(&module) {
+        return None;
+    }
+    let module_def = sema.to_def(&module)?;
+
+    let path = module_def
+        .path_to_root(sema.db)
+        .into_iter()
+        .rev()
+        .filter_map(|it| it.name(sema.db))
+        .join("::");
+
+    let def = sema.to_def(&module)?;
+    let attrs = def.attrs(sema.db);
+    let cfg = attrs.cfg();
+    let nav = module_def.to_nav(sema.db);
+    Some(Runnable { nav, kind: RunnableKind::TestMod { path }, cfg })
+}
+
 fn runnable_doctest(sema: &Semantics<RootDatabase>, item: SyntaxNode) -> Option<Runnable> {
     match_ast! {
         match item {
@@ -253,26 +278,6 @@ fn has_runnable_doc_test(attrs: &hir::Attrs) -> bool {
     })
 }
 
-fn runnable_mod(sema: &Semantics<RootDatabase>, module: ast::Module) -> Option<Runnable> {
-    if !has_test_function_or_multiple_test_submodules(&module) {
-        return None;
-    }
-    let module_def = sema.to_def(&module)?;
-
-    let path = module_def
-        .path_to_root(sema.db)
-        .into_iter()
-        .rev()
-        .filter_map(|it| it.name(sema.db))
-        .join("::");
-
-    let def = sema.to_def(&module)?;
-    let attrs = def.attrs(sema.db);
-    let cfg = attrs.cfg();
-    let nav = module_def.to_nav(sema.db);
-    Some(Runnable { nav, kind: RunnableKind::TestMod { path }, cfg })
-}
-
 // We could create runnables for modules with number_of_test_submodules > 0,
 // but that bloats the runnables for no real benefit, since all tests can be run by the submodule already
 fn has_test_function_or_multiple_test_submodules(module: &ast::Module) -> bool {
diff --git a/crates/ide/src/syntax_highlighting/highlight.rs b/crates/ide/src/syntax_highlighting/highlight.rs
index 0cb58d589..34bae49a8 100644
--- a/crates/ide/src/syntax_highlighting/highlight.rs
+++ b/crates/ide/src/syntax_highlighting/highlight.rs
@@ -339,8 +339,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)
@@ -356,7 +359,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/src/syntax_highlighting/highlights.rs b/crates/ide/src/syntax_highlighting/highlights.rs
index 11c11ed28..c6f0417ec 100644
--- a/crates/ide/src/syntax_highlighting/highlights.rs
+++ b/crates/ide/src/syntax_highlighting/highlights.rs
@@ -51,18 +51,20 @@ impl Node {
             }
         }
 
-        let (start, len) =
+        let overlapping =
             equal_range_by(&self.nested, |n| ordering(n.hl_range.range, hl_range.range));
 
-        if len == 1 && self.nested[start].hl_range.range.contains_range(hl_range.range) {
-            return self.nested[start].add(hl_range);
+        if overlapping.len() == 1
+            && self.nested[overlapping.start].hl_range.range.contains_range(hl_range.range)
+        {
+            return self.nested[overlapping.start].add(hl_range);
         }
 
         let nested = self
             .nested
-            .splice(start..start + len, iter::once(Node::new(hl_range)))
+            .splice(overlapping.clone(), iter::once(Node::new(hl_range)))
             .collect::<Vec<_>>();
-        self.nested[start].nested = nested;
+        self.nested[overlapping.start].nested = nested;
     }
 
     fn flatten(&self, acc: &mut Vec<HlRange>) {
diff --git a/crates/ide/src/syntax_highlighting/injector.rs b/crates/ide/src/syntax_highlighting/injector.rs
index e8f17eb69..fd4025694 100644
--- a/crates/ide/src/syntax_highlighting/injector.rs
+++ b/crates/ide/src/syntax_highlighting/injector.rs
@@ -33,8 +33,7 @@ impl Injector {
         &self.buf
     }
     pub(super) fn map_range_up(&self, range: TextRange) -> impl Iterator<Item = TextRange> + '_ {
-        let (start, len) = equal_range_by(&self.ranges, |&(r, _)| ordering(r, range));
-        (start..start + len).filter_map(move |i| {
+        equal_range_by(&self.ranges, |&(r, _)| ordering(r, range)).filter_map(move |i| {
             let (target_range, delta) = self.ranges[i];
             let intersection = target_range.intersect(range).unwrap();
             Some(intersection + delta?)
diff --git a/crates/ide_db/src/defs.rs b/crates/ide_db/src/defs.rs
index be1c64b03..d68fe42b0 100644
--- 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,7 +385,8 @@ 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
@@ -401,7 +394,8 @@ impl NameRefClass {
                 != 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
index 37b06027c..773bfbc2c 100644
--- 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()))
diff --git a/crates/stdx/src/lib.rs b/crates/stdx/src/lib.rs
index 5aacdb16e..13aab1451 100644
--- a/crates/stdx/src/lib.rs
+++ b/crates/stdx/src/lib.rs
@@ -152,13 +152,13 @@ where
     left
 }
 
-pub fn equal_range_by<T, F>(slice: &[T], mut key: F) -> (usize, usize)
+pub fn equal_range_by<T, F>(slice: &[T], mut key: F) -> ops::Range<usize>
 where
     F: FnMut(&T) -> Ordering,
 {
     let start = partition_point(slice, |it| key(it) == Ordering::Less);
     let len = partition_point(&slice[start..], |it| key(it) == Ordering::Equal);
-    (start, len)
+    start..start + len
 }
 
 pub struct JodChild(pub process::Child);