1 files changed, 50 insertions, 13 deletions

diff --git a/crates/ide_db/src/search.rs b/crates/ide_db/src/search.rs
index 3936c7390..5b3997bcf 100644
--- a/crates/ide_db/src/search.rs
+++ b/crates/ide_db/src/search.rs
@@ -33,6 +33,7 @@ pub enum ReferenceKind {
     RecordFieldExprOrPat,
     SelfKw,
     EnumLiteral,
+    Lifetime,
     Other,
 }
 
@@ -129,6 +130,25 @@ impl Definition {
             return SearchScope::new(res);
         }
 
+        if let Definition::LifetimeParam(param) = self {
+            let range = match param.parent(db) {
+                hir::GenericDef::Function(it) => it.source(db).value.syntax().text_range(),
+                hir::GenericDef::Adt(it) => match it {
+                    hir::Adt::Struct(it) => it.source(db).value.syntax().text_range(),
+                    hir::Adt::Union(it) => it.source(db).value.syntax().text_range(),
+                    hir::Adt::Enum(it) => it.source(db).value.syntax().text_range(),
+                },
+                hir::GenericDef::Trait(it) => it.source(db).value.syntax().text_range(),
+                hir::GenericDef::TypeAlias(it) => it.source(db).value.syntax().text_range(),
+                hir::GenericDef::ImplDef(it) => it.source(db).value.syntax().text_range(),
+                hir::GenericDef::EnumVariant(it) => it.source(db).value.syntax().text_range(),
+                hir::GenericDef::Const(it) => it.source(db).value.syntax().text_range(),
+            };
+            let mut res = FxHashMap::default();
+            res.insert(file_id, Some(range));
+            return SearchScope::new(res);
+        }
+
         let vis = self.visibility(db);
 
         if let Some(Visibility::Module(module)) = vis.and_then(|it| it.into()) {
@@ -255,25 +275,42 @@ impl<'a> FindUsages<'a> {
                     continue;
                 }
 
-                match sema.find_node_at_offset_with_descend(&tree, offset) {
-                    Some(name_ref) => {
-                        if self.found_name_ref(&name_ref, sink) {
-                            return;
-                        }
+                if let Some(name_ref) = sema.find_node_at_offset_with_descend(&tree, offset) {
+                    if self.found_name_ref(&name_ref, sink) {
+                        return;
+                    }
+                } else if let Some(name) = sema.find_node_at_offset_with_descend(&tree, offset) {
+                    if self.found_name(&name, sink) {
+                        return;
+                    }
+                } else if let Some(lifetime) = sema.find_node_at_offset_with_descend(&tree, offset)
+                {
+                    if self.found_lifetime(&lifetime, sink) {
+                        return;
                     }
-                    None => match sema.find_node_at_offset_with_descend(&tree, offset) {
-                        Some(name) => {
-                            if self.found_name(&name, sink) {
-                                return;
-                            }
-                        }
-                        None => {}
-                    },
                 }
             }
         }
     }
 
+    fn found_lifetime(
+        &self,
+        lifetime: &ast::Lifetime,
+        sink: &mut dyn FnMut(Reference) -> bool,
+    ) -> bool {
+        match NameRefClass::classify_lifetime(self.sema, lifetime) {
+            Some(NameRefClass::Definition(def)) if &def == self.def => {
+                let reference = Reference {
+                    file_range: self.sema.original_range(lifetime.syntax()),
+                    kind: ReferenceKind::Lifetime,
+                    access: None,
+                };
+                sink(reference)
+            }
+            _ => false, // not a usage
+        }
+    }
+
     fn found_name_ref(
         &self,
         name_ref: &ast::NameRef,