15 files changed, 384 insertions, 140 deletions

diff --git a/crates/assists/src/handlers/reorder_fields.rs b/crates/assists/src/handlers/reorder_fields.rs
index 7c0f0f44e..fe5574242 100644
--- a/crates/assists/src/handlers/reorder_fields.rs
+++ b/crates/assists/src/handlers/reorder_fields.rs
@@ -4,6 +4,7 @@ use rustc_hash::FxHashMap;
 use hir::{Adt, ModuleDef, PathResolution, Semantics, Struct};
 use ide_db::RootDatabase;
 use syntax::{algo, ast, match_ast, AstNode, SyntaxKind, SyntaxKind::*, SyntaxNode};
+use test_utils::mark;
 
 use crate::{AssistContext, AssistId, AssistKind, Assists};
 
@@ -38,6 +39,7 @@ fn reorder<R: AstNode>(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
     });
 
     if sorted_fields == fields {
+        mark::hit!(reorder_sorted_fields);
         return None;
     }
 
@@ -107,22 +109,25 @@ fn compute_fields_ranks(path: &ast::Path, ctx: &AssistContext) -> Option<FxHashM
 
 #[cfg(test)]
 mod tests {
+    use test_utils::mark;
+
     use crate::tests::{check_assist, check_assist_not_applicable};
 
     use super::*;
 
     #[test]
-    fn not_applicable_if_sorted() {
+    fn reorder_sorted_fields() {
+        mark::check!(reorder_sorted_fields);
         check_assist_not_applicable(
             reorder_fields,
             r#"
-        struct Foo {
-            foo: i32,
-            bar: i32,
-        }
+struct Foo {
+    foo: i32,
+    bar: i32,
+}
 
-        const test: Foo = <|>Foo { foo: 0, bar: 0 };
-        "#,
+const test: Foo = <|>Foo { foo: 0, bar: 0 };
+"#,
         )
     }
 
@@ -131,9 +136,9 @@ mod tests {
         check_assist_not_applicable(
             reorder_fields,
             r#"
-        struct Foo {};
-        const test: Foo = <|>Foo {}
-        "#,
+struct Foo {};
+const test: Foo = <|>Foo {}
+"#,
         )
     }
 
@@ -142,13 +147,13 @@ mod tests {
         check_assist(
             reorder_fields,
             r#"
-        struct Foo {foo: i32, bar: i32};
-        const test: Foo = <|>Foo {bar: 0, foo: 1}
-        "#,
+struct Foo {foo: i32, bar: i32};
+const test: Foo = <|>Foo {bar: 0, foo: 1}
+"#,
             r#"
-        struct Foo {foo: i32, bar: i32};
-        const test: Foo = Foo {foo: 1, bar: 0}
-        "#,
+struct Foo {foo: i32, bar: i32};
+const test: Foo = Foo {foo: 1, bar: 0}
+"#,
         )
     }
 
@@ -157,25 +162,25 @@ mod tests {
         check_assist(
             reorder_fields,
             r#"
-        struct Foo { foo: i64, bar: i64, baz: i64 }
+struct Foo { foo: i64, bar: i64, baz: i64 }
 
-        fn f(f: Foo) -> {
-            match f {
-                <|>Foo { baz: 0, ref mut bar, .. } => (),
-                _ => ()
-            }
-        }
-        "#,
+fn f(f: Foo) -> {
+    match f {
+        <|>Foo { baz: 0, ref mut bar, .. } => (),
+        _ => ()
+    }
+}
+"#,
             r#"
-        struct Foo { foo: i64, bar: i64, baz: i64 }
+struct Foo { foo: i64, bar: i64, baz: i64 }
 
-        fn f(f: Foo) -> {
-            match f {
-                Foo { ref mut bar, baz: 0, .. } => (),
-                _ => ()
-            }
-        }
-        "#,
+fn f(f: Foo) -> {
+    match f {
+        Foo { ref mut bar, baz: 0, .. } => (),
+        _ => ()
+    }
+}
+"#,
         )
     }
 
@@ -184,39 +189,39 @@ mod tests {
         check_assist(
             reorder_fields,
             r#"
-            struct Foo {
-                foo: String,
-                bar: String,
-            }
+struct Foo {
+    foo: String,
+    bar: String,
+}
 
-            impl Foo {
-                fn new() -> Foo {
-                    let foo = String::new();
-                    <|>Foo {
-                        bar: foo.clone(),
-                        extra: "Extra field",
-                        foo,
-                    }
-                }
-            }
-            "#,
+impl Foo {
+    fn new() -> Foo {
+        let foo = String::new();
+        <|>Foo {
+            bar: foo.clone(),
+            extra: "Extra field",
+            foo,
+        }
+    }
+}
+"#,
             r#"
-            struct Foo {
-                foo: String,
-                bar: String,
-            }
+struct Foo {
+    foo: String,
+    bar: String,
+}
 
-            impl Foo {
-                fn new() -> Foo {
-                    let foo = String::new();
-                    Foo {
-                        foo,
-                        bar: foo.clone(),
-                        extra: "Extra field",
-                    }
-                }
-            }
-            "#,
+impl Foo {
+    fn new() -> Foo {
+        let foo = String::new();
+        Foo {
+            foo,
+            bar: foo.clone(),
+            extra: "Extra field",
+        }
+    }
+}
+"#,
         )
     }
 }
diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index fcc42c6bb..42dc35b76 100644
--- a/crates/hir/src/code_model.rs
+++ b/crates/hir/src/code_model.rs
@@ -1250,6 +1250,14 @@ impl LifetimeParam {
         let params = db.generic_params(self.id.parent);
         params.lifetimes[self.id.local_id].name.clone()
     }
+
+    pub fn module(self, db: &dyn HirDatabase) -> Module {
+        self.id.parent.module(db.upcast()).into()
+    }
+
+    pub fn parent(self, _db: &dyn HirDatabase) -> GenericDef {
+        self.id.parent.into()
+    }
 }
 
 // FIXME: rename from `ImplDef` to `Impl`
diff --git a/crates/hir/src/from_id.rs b/crates/hir/src/from_id.rs
index 265ef6d1f..dd3fcfe4a 100644
--- a/crates/hir/src/from_id.rs
+++ b/crates/hir/src/from_id.rs
@@ -41,6 +41,7 @@ from_id![
     (hir_def::FunctionId, crate::Function),
     (hir_def::ImplId, crate::ImplDef),
     (hir_def::TypeParamId, crate::TypeParam),
+    (hir_def::LifetimeParamId, crate::LifetimeParam),
     (hir_expand::MacroDefId, crate::MacroDef)
 ];
 
@@ -154,6 +155,22 @@ impl From<GenericDef> for GenericDefId {
     }
 }
 
+impl From<GenericDefId> for GenericDef {
+    fn from(def: GenericDefId) -> Self {
+        match def {
+            GenericDefId::FunctionId(it) => GenericDef::Function(it.into()),
+            GenericDefId::AdtId(it) => GenericDef::Adt(it.into()),
+            GenericDefId::TraitId(it) => GenericDef::Trait(it.into()),
+            GenericDefId::TypeAliasId(it) => GenericDef::TypeAlias(it.into()),
+            GenericDefId::ImplId(it) => GenericDef::ImplDef(it.into()),
+            GenericDefId::EnumVariantId(it) => {
+                GenericDef::EnumVariant(EnumVariant { parent: it.parent.into(), id: it.local_id })
+            }
+            GenericDefId::ConstId(it) => GenericDef::Const(it.into()),
+        }
+    }
+}
+
 impl From<Adt> for GenericDefId {
     fn from(id: Adt) -> Self {
         match id {
diff --git a/crates/hir/src/has_source.rs b/crates/hir/src/has_source.rs
index c77494152..1e64a1614 100644
--- a/crates/hir/src/has_source.rs
+++ b/crates/hir/src/has_source.rs
@@ -10,8 +10,8 @@ use hir_expand::InFile;
 use syntax::ast;
 
 use crate::{
-    db::HirDatabase, Const, Enum, EnumVariant, Field, FieldSource, Function, ImplDef, MacroDef,
-    Module, Static, Struct, Trait, TypeAlias, TypeParam, Union,
+    db::HirDatabase, Const, Enum, EnumVariant, Field, FieldSource, Function, ImplDef,
+    LifetimeParam, MacroDef, Module, Static, Struct, Trait, TypeAlias, TypeParam, Union,
 };
 
 pub trait HasSource {
@@ -129,6 +129,14 @@ impl HasSource for TypeParam {
     type Ast = Either<ast::Trait, ast::TypeParam>;
     fn source(self, db: &dyn HirDatabase) -> InFile<Self::Ast> {
         let child_source = self.id.parent.child_source(db.upcast());
-        child_source.map(|it| it[self.id.local_id].clone())
+        child_source.map(|it| it.type_params[self.id.local_id].clone())
+    }
+}
+
+impl HasSource for LifetimeParam {
+    type Ast = ast::LifetimeParam;
+    fn source(self, db: &dyn HirDatabase) -> InFile<Self::Ast> {
+        let child_source = self.id.parent.child_source(db.upcast());
+        child_source.map(|it| it.lifetime_params[self.id.local_id].clone())
     }
 }
diff --git a/crates/hir/src/semantics.rs b/crates/hir/src/semantics.rs
index 4bd22ed27..e4fc21ced 100644
--- a/crates/hir/src/semantics.rs
+++ b/crates/hir/src/semantics.rs
@@ -13,7 +13,11 @@ use hir_expand::{hygiene::Hygiene, name::AsName, ExpansionInfo};
 use hir_ty::associated_type_shorthand_candidates;
 use itertools::Itertools;
 use rustc_hash::{FxHashMap, FxHashSet};
-use syntax::{algo::find_node_at_offset, ast, AstNode, SyntaxNode, SyntaxToken, TextSize};
+use syntax::{
+    algo::find_node_at_offset,
+    ast::{self, GenericParamsOwner},
+    match_ast, AstNode, SyntaxNode, SyntaxToken, TextSize,
+};
 
 use crate::{
     code_model::Access,
@@ -21,8 +25,9 @@ use crate::{
     diagnostics::Diagnostic,
     semantics::source_to_def::{ChildContainer, SourceToDefCache, SourceToDefCtx},
     source_analyzer::{resolve_hir_path, SourceAnalyzer},
-    AssocItem, Callable, Crate, Field, Function, HirFileId, ImplDef, InFile, Local, MacroDef,
-    Module, ModuleDef, Name, Path, ScopeDef, Trait, Type, TypeAlias, TypeParam, VariantDef,
+    AssocItem, Callable, Crate, Field, Function, HirFileId, ImplDef, InFile, LifetimeParam, Local,
+    MacroDef, Module, ModuleDef, Name, Path, ScopeDef, Trait, Type, TypeAlias, TypeParam,
+    VariantDef,
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -173,6 +178,11 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
         self.imp.descend_node_at_offset(node, offset).find_map(N::cast)
     }
 
+    // FIXME: Replace the SyntaxToken with a typed ast Node/Token
+    pub fn resolve_lifetime_param(&self, lifetime_token: &SyntaxToken) -> Option<LifetimeParam> {
+        self.imp.resolve_lifetime_param(lifetime_token)
+    }
+
     pub fn type_of_expr(&self, expr: &ast::Expr) -> Option<Type> {
         self.imp.type_of_expr(expr)
     }
@@ -392,16 +402,44 @@ impl<'db> SemanticsImpl<'db> {
             .kmerge_by(|node1, node2| node1.text_range().len() < node2.text_range().len())
     }
 
+    // FIXME: Replace the SyntaxToken with a typed ast Node/Token
+    fn resolve_lifetime_param(&self, lifetime_token: &SyntaxToken) -> Option<LifetimeParam> {
+        if lifetime_token.kind() != syntax::SyntaxKind::LIFETIME {
+            return None;
+        }
+        let lifetime_text = lifetime_token.text();
+        let lifetime_param = lifetime_token.parent().ancestors().find_map(|syn| {
+            let gpl = match_ast! {
+                match syn {
+                    ast::Fn(it) => it.generic_param_list()?,
+                    ast::TypeAlias(it) => it.generic_param_list()?,
+                    ast::Struct(it) => it.generic_param_list()?,
+                    ast::Enum(it) => it.generic_param_list()?,
+                    ast::Union(it) => it.generic_param_list()?,
+                    ast::Trait(it) => it.generic_param_list()?,
+                    ast::Impl(it) => it.generic_param_list()?,
+                    ast::WherePred(it) => it.generic_param_list()?,
+                    ast::ForType(it) => it.generic_param_list()?,
+                    _ => return None,
+                }
+            };
+            gpl.lifetime_params()
+                .find(|tp| tp.lifetime_token().as_ref().map(|lt| lt.text()) == Some(lifetime_text))
+        })?;
+        let src = self.find_file(lifetime_param.syntax().clone()).with_value(lifetime_param);
+        ToDef::to_def(self, src)
+    }
+
     fn type_of_expr(&self, expr: &ast::Expr) -> Option<Type> {
-        self.analyze(expr.syntax()).type_of_expr(self.db, &expr)
+        self.analyze(expr.syntax()).type_of_expr(self.db, expr)
     }
 
     fn type_of_pat(&self, pat: &ast::Pat) -> Option<Type> {
-        self.analyze(pat.syntax()).type_of_pat(self.db, &pat)
+        self.analyze(pat.syntax()).type_of_pat(self.db, pat)
     }
 
     fn type_of_self(&self, param: &ast::SelfParam) -> Option<Type> {
-        self.analyze(param.syntax()).type_of_self(self.db, &param)
+        self.analyze(param.syntax()).type_of_self(self.db, param)
     }
 
     fn resolve_method_call(&self, call: &ast::MethodCallExpr) -> Option<FunctionId> {
@@ -684,6 +722,7 @@ to_def_impls![
     (crate::Field, ast::TupleField, tuple_field_to_def),
     (crate::EnumVariant, ast::Variant, enum_variant_to_def),
     (crate::TypeParam, ast::TypeParam, type_param_to_def),
+    (crate::LifetimeParam, ast::LifetimeParam, lifetime_param_to_def),
     (crate::MacroDef, ast::MacroCall, macro_call_to_def), // this one is dubious, not all calls are macros
     (crate::Local, ast::IdentPat, bind_pat_to_def),
 ];
diff --git a/crates/hir/src/semantics/source_to_def.rs b/crates/hir/src/semantics/source_to_def.rs
index 66fc11611..badcf0ae8 100644
--- a/crates/hir/src/semantics/source_to_def.rs
+++ b/crates/hir/src/semantics/source_to_def.rs
@@ -7,7 +7,8 @@ use hir_def::{
     expr::PatId,
     keys::{self, Key},
     ConstId, DefWithBodyId, EnumId, EnumVariantId, FieldId, FunctionId, GenericDefId, ImplId,
-    ModuleId, StaticId, StructId, TraitId, TypeAliasId, TypeParamId, UnionId, VariantId,
+    LifetimeParamId, ModuleId, StaticId, StructId, TraitId, TypeAliasId, TypeParamId, UnionId,
+    VariantId,
 };
 use hir_expand::{name::AsName, AstId, MacroDefKind};
 use rustc_hash::FxHashMap;
@@ -128,13 +129,25 @@ impl SourceToDefCtx<'_, '_> {
 
     pub(super) fn type_param_to_def(&mut self, src: InFile<ast::TypeParam>) -> Option<TypeParamId> {
         let container: ChildContainer =
-            self.find_type_param_container(src.as_ref().map(|it| it.syntax()))?.into();
+            self.find_generic_param_container(src.as_ref().map(|it| it.syntax()))?.into();
         let db = self.db;
         let dyn_map =
             &*self.cache.entry(container).or_insert_with(|| container.child_by_source(db));
         dyn_map[keys::TYPE_PARAM].get(&src).copied()
     }
 
+    pub(super) fn lifetime_param_to_def(
+        &mut self,
+        src: InFile<ast::LifetimeParam>,
+    ) -> Option<LifetimeParamId> {
+        let container: ChildContainer =
+            self.find_generic_param_container(src.as_ref().map(|it| it.syntax()))?.into();
+        let db = self.db;
+        let dyn_map =
+            &*self.cache.entry(container).or_insert_with(|| container.child_by_source(db));
+        dyn_map[keys::LIFETIME_PARAM].get(&src).copied()
+    }
+
     // FIXME: use DynMap as well?
     pub(super) fn macro_call_to_def(&mut self, src: InFile<ast::MacroCall>) -> Option<MacroDefId> {
         let kind = MacroDefKind::Declarative;
@@ -203,7 +216,7 @@ impl SourceToDefCtx<'_, '_> {
         Some(def.into())
     }
 
-    fn find_type_param_container(&mut self, src: InFile<&SyntaxNode>) -> Option<GenericDefId> {
+    fn find_generic_param_container(&mut self, src: InFile<&SyntaxNode>) -> Option<GenericDefId> {
         for container in src.cloned().ancestors_with_macros(self.db.upcast()).skip(1) {
             let res: GenericDefId = match_ast! {
                 match (container.value) {
@@ -247,7 +260,7 @@ pub(crate) enum ChildContainer {
     VariantId(VariantId),
     TypeAliasId(TypeAliasId),
     /// XXX: this might be the same def as, for example an `EnumId`. However,
-    /// here the children generic parameters, and not, eg enum variants.
+    /// here the children are generic parameters, and not, eg enum variants.
     GenericDefId(GenericDefId),
 }
 impl_from! {
diff --git a/crates/hir_def/src/generics.rs b/crates/hir_def/src/generics.rs
index 5189c7e9f..81912a454 100644
--- a/crates/hir_def/src/generics.rs
+++ b/crates/hir_def/src/generics.rs
@@ -19,10 +19,10 @@ use crate::{
     db::DefDatabase,
     dyn_map::DynMap,
     keys,
-    src::HasChildSource,
     src::HasSource,
     type_ref::{LifetimeRef, TypeBound, TypeRef},
-    AdtId, GenericDefId, LocalTypeParamId, Lookup, TypeParamId,
+    AdtId, GenericDefId, LifetimeParamId, LocalLifetimeParamId, LocalTypeParamId, Lookup,
+    TypeParamId,
 };
 
 /// Data about a generic parameter (to a function, struct, impl, ...).
@@ -72,7 +72,11 @@ pub enum WherePredicateTypeTarget {
     // FIXME: ForLifetime(Vec<LifetimeParamId>, TypeRef)
 }
 
-type SourceMap = ArenaMap<LocalTypeParamId, Either<ast::Trait, ast::TypeParam>>;
+#[derive(Default)]
+pub struct SourceMaps {
+    pub type_params: ArenaMap<LocalTypeParamId, Either<ast::Trait, ast::TypeParam>>,
+    pub lifetime_params: ArenaMap<LocalLifetimeParamId, ast::LifetimeParam>,
+}
 
 impl GenericParams {
     pub(crate) fn generic_params_query(
@@ -129,9 +133,9 @@ impl GenericParams {
         Arc::new(generics)
     }
 
-    fn new(db: &dyn DefDatabase, def: GenericDefId) -> (GenericParams, InFile<SourceMap>) {
+    fn new(db: &dyn DefDatabase, def: GenericDefId) -> (GenericParams, InFile<SourceMaps>) {
         let mut generics = GenericParams::default();
-        let mut sm = ArenaMap::default();
+        let mut sm = SourceMaps::default();
 
         // FIXME: add `: Sized` bound for everything except for `Self` in traits
         let file_id = match def {
@@ -174,7 +178,7 @@ impl GenericParams {
                     default: None,
                     provenance: TypeParamProvenance::TraitSelf,
                 });
-                sm.insert(self_param_id, Either::Left(src.value.clone()));
+                sm.type_params.insert(self_param_id, Either::Left(src.value.clone()));
                 // add super traits as bounds on Self
                 // i.e., trait Foo: Bar is equivalent to trait Foo where Self: Bar
                 let self_param = TypeRef::Path(name![Self].into());
@@ -210,7 +214,7 @@ impl GenericParams {
     pub(crate) fn fill(
         &mut self,
         lower_ctx: &LowerCtx,
-        sm: &mut SourceMap,
+        sm: &mut SourceMaps,
         node: &dyn GenericParamsOwner,
     ) {
         if let Some(params) = node.generic_param_list() {
@@ -237,7 +241,7 @@ impl GenericParams {
     fn fill_params(
         &mut self,
         lower_ctx: &LowerCtx,
-        sm: &mut SourceMap,
+        sm: &mut SourceMaps,
         params: ast::GenericParamList,
     ) {
         for type_param in params.type_params() {
@@ -250,7 +254,7 @@ impl GenericParams {
                 provenance: TypeParamProvenance::TypeParamList,
             };
             let param_id = self.types.alloc(param);
-            sm.insert(param_id, Either::Right(type_param.clone()));
+            sm.type_params.insert(param_id, Either::Right(type_param.clone()));
 
             let type_ref = TypeRef::Path(name.into());
             self.fill_bounds(&lower_ctx, &type_param, Either::Left(type_ref));
@@ -260,7 +264,8 @@ impl GenericParams {
                 .lifetime_token()
                 .map_or_else(Name::missing, |tok| Name::new_lifetime(&tok));
             let param = LifetimeParamData { name: name.clone() };
-            let _param_id = self.lifetimes.alloc(param);
+            let param_id = self.lifetimes.alloc(param);
+            sm.lifetime_params.insert(param_id, lifetime_param.clone());
             let lifetime_ref = LifetimeRef::new_name(name);
             self.fill_bounds(&lower_ctx, &lifetime_param, Either::Right(lifetime_ref));
         }
@@ -340,27 +345,29 @@ impl GenericParams {
         })
     }
 }
-
-impl HasChildSource for GenericDefId {
-    type ChildId = LocalTypeParamId;
-    type Value = Either<ast::Trait, ast::TypeParam>;
-    fn child_source(&self, db: &dyn DefDatabase) -> InFile<SourceMap> {
-        let (_, sm) = GenericParams::new(db, *self);
-        sm
+impl GenericDefId {
+    // FIXME: Change HasChildSource's ChildId AssocItem to be a generic parameter instead
+    pub fn child_source(&self, db: &dyn DefDatabase) -> InFile<SourceMaps> {
+        GenericParams::new(db, *self).1
     }
 }
 
 impl ChildBySource for GenericDefId {
     fn child_by_source(&self, db: &dyn DefDatabase) -> DynMap {
         let mut res = DynMap::default();
-        let arena_map = self.child_source(db);
-        let arena_map = arena_map.as_ref();
-        for (local_id, src) in arena_map.value.iter() {
+        let (_, sm) = GenericParams::new(db, *self);
+
+        let sm = sm.as_ref();
+        for (local_id, src) in sm.value.type_params.iter() {
             let id = TypeParamId { parent: *self, local_id };
             if let Either::Right(type_param) = src {
-                res[keys::TYPE_PARAM].insert(arena_map.with_value(type_param.clone()), id)
+                res[keys::TYPE_PARAM].insert(sm.with_value(type_param.clone()), id)
             }
         }
+        for (local_id, src) in sm.value.lifetime_params.iter() {
+            let id = LifetimeParamId { parent: *self, local_id };
+            res[keys::LIFETIME_PARAM].insert(sm.with_value(src.clone()), id);
+        }
         res
     }
 }
diff --git a/crates/hir_def/src/item_tree/lower.rs b/crates/hir_def/src/item_tree/lower.rs
index f7ce2e26d..2939c6b1e 100644
--- a/crates/hir_def/src/item_tree/lower.rs
+++ b/crates/hir_def/src/item_tree/lower.rs
@@ -2,7 +2,6 @@
 
 use std::{collections::hash_map::Entry, mem, sync::Arc};
 
-use arena::map::ArenaMap;
 use hir_expand::{ast_id_map::AstIdMap, hygiene::Hygiene, name::known, HirFileId};
 use smallvec::SmallVec;
 use syntax::{
@@ -607,7 +606,7 @@ impl Ctx {
         owner: GenericsOwner<'_>,
         node: &impl ast::GenericParamsOwner,
     ) -> GenericParamsId {
-        let mut sm = &mut ArenaMap::default();
+        let mut sm = &mut Default::default();
         let mut generics = GenericParams::default();
         match owner {
             GenericsOwner::Function(func) => {
@@ -630,7 +629,7 @@ impl Ctx {
                     default: None,
                     provenance: TypeParamProvenance::TraitSelf,
                 });
-                sm.insert(self_param_id, Either::Left(trait_def.clone()));
+                sm.type_params.insert(self_param_id, Either::Left(trait_def.clone()));
                 // add super traits as bounds on Self
                 // i.e., trait Foo: Bar is equivalent to trait Foo where Self: Bar
                 let self_param = TypeRef::Path(name![Self].into());
diff --git a/crates/hir_def/src/keys.rs b/crates/hir_def/src/keys.rs
index 40a5d92b5..9c585de2c 100644
--- a/crates/hir_def/src/keys.rs
+++ b/crates/hir_def/src/keys.rs
@@ -8,8 +8,8 @@ use syntax::{ast, AstNode, AstPtr};
 
 use crate::{
     dyn_map::{DynMap, Policy},
-    ConstId, EnumId, EnumVariantId, FieldId, FunctionId, ImplId, StaticId, StructId, TraitId,
-    TypeAliasId, TypeParamId, UnionId,
+    ConstId, EnumId, EnumVariantId, FieldId, FunctionId, ImplId, LifetimeParamId, StaticId,
+    StructId, TraitId, TypeAliasId, TypeParamId, UnionId,
 };
 
 pub type Key<K, V> = crate::dyn_map::Key<InFile<K>, V, AstPtrPolicy<K, V>>;
@@ -28,6 +28,7 @@ pub const VARIANT: Key<ast::Variant, EnumVariantId> = Key::new();
 pub const TUPLE_FIELD: Key<ast::TupleField, FieldId> = Key::new();
 pub const RECORD_FIELD: Key<ast::RecordField, FieldId> = Key::new();
 pub const TYPE_PARAM: Key<ast::TypeParam, TypeParamId> = Key::new();
+pub const LIFETIME_PARAM: Key<ast::LifetimeParam, LifetimeParamId> = Key::new();
 
 pub const MACRO: Key<ast::MacroCall, MacroDefId> = Key::new();
 
diff --git a/crates/hir_expand/src/builtin_macro.rs b/crates/hir_expand/src/builtin_macro.rs
index 477192a09..b1b432ded 100644
--- a/crates/hir_expand/src/builtin_macro.rs
+++ b/crates/hir_expand/src/builtin_macro.rs
@@ -88,12 +88,15 @@ register_builtin! {
     (column, Column) => column_expand,
     (file, File) => file_expand,
     (line, Line) => line_expand,
+    (module_path, ModulePath) => module_path_expand,
     (assert, Assert) => assert_expand,
     (stringify, Stringify) => stringify_expand,
     (format_args, FormatArgs) => format_args_expand,
     // format_args_nl only differs in that it adds a newline in the end,
     // so we use the same stub expansion for now
     (format_args_nl, FormatArgsNl) => format_args_expand,
+    (llvm_asm, LlvmAsm) => asm_expand,
+    (asm, Asm) => asm_expand,
 
     EAGER:
     (compile_error, CompileError) => compile_error_expand,
@@ -105,6 +108,15 @@ register_builtin! {
     (option_env, OptionEnv) => option_env_expand
 }
 
+fn module_path_expand(
+    _db: &dyn AstDatabase,
+    _id: LazyMacroId,
+    _tt: &tt::Subtree,
+) -> ExpandResult<tt::Subtree> {
+    // Just return a dummy result.
+    ExpandResult::ok(quote! { "module::path" })
+}
+
 fn line_expand(
     _db: &dyn AstDatabase,
     _id: LazyMacroId,
@@ -261,6 +273,19 @@ fn format_args_expand(
     ExpandResult::ok(expanded)
 }
 
+fn asm_expand(
+    _db: &dyn AstDatabase,
+    _id: LazyMacroId,
+    _tt: &tt::Subtree,
+) -> ExpandResult<tt::Subtree> {
+    // both asm and llvm_asm don't return anything, so we can expand them to nothing,
+    // for now
+    let expanded = quote! {
+        ()
+    };
+    ExpandResult::ok(expanded)
+}
+
 fn unquote_str(lit: &tt::Literal) -> Option<String> {
     let lit = ast::make::tokens::literal(&lit.to_string());
     let token = ast::String::cast(lit)?;
diff --git a/crates/hir_expand/src/name.rs b/crates/hir_expand/src/name.rs
index 583ed6142..69d8e6803 100644
--- a/crates/hir_expand/src/name.rs
+++ b/crates/hir_expand/src/name.rs
@@ -188,6 +188,7 @@ pub mod known {
         column,
         compile_error,
         line,
+        module_path,
         assert,
         stringify,
         concat,
@@ -198,6 +199,8 @@ pub mod known {
         format_args_nl,
         env,
         option_env,
+        llvm_asm,
+        asm,
         // Builtin derives
         Copy,
         Clone,
diff --git a/crates/ide/src/references.rs b/crates/ide/src/references.rs
index 7395b81bd..66f0f7950 100644
--- a/crates/ide/src/references.rs
+++ b/crates/ide/src/references.rs
@@ -97,6 +97,9 @@ pub(crate) fn find_all_refs(
         get_struct_def_name_for_struct_literal_search(&sema, &syntax, position)
     {
         (Some(name), ReferenceKind::StructLiteral)
+    } else if let Some(name) = get_enum_def_name_for_struct_literal_search(&sema, &syntax, position)
+    {
+        (Some(name), ReferenceKind::EnumLiteral)
     } else {
         (
             sema.find_node_at_offset_with_descend::<ast::Name>(&syntax, position.offset),
@@ -198,6 +201,33 @@ fn get_struct_def_name_for_struct_literal_search(
     None
 }
 
+fn get_enum_def_name_for_struct_literal_search(
+    sema: &Semantics<RootDatabase>,
+    syntax: &SyntaxNode,
+    position: FilePosition,
+) -> Option<ast::Name> {
+    if let TokenAtOffset::Between(ref left, ref right) = syntax.token_at_offset(position.offset) {
+        if right.kind() != SyntaxKind::L_CURLY && right.kind() != SyntaxKind::L_PAREN {
+            return None;
+        }
+        if let Some(name) =
+            sema.find_node_at_offset_with_descend::<ast::Name>(&syntax, left.text_range().start())
+        {
+            return name.syntax().ancestors().find_map(ast::Enum::cast).and_then(|l| l.name());
+        }
+        if sema
+            .find_node_at_offset_with_descend::<ast::GenericParamList>(
+                &syntax,
+                left.text_range().start(),
+            )
+            .is_some()
+        {
+            return left.ancestors().find_map(ast::Enum::cast).and_then(|l| l.name());
+        }
+    }
+    None
+}
+
 fn try_find_self_references(
     syntax: &SyntaxNode,
     position: FilePosition,
@@ -357,6 +387,91 @@ fn main() {
     }
 
     #[test]
+    fn test_enum_after_space() {
+        check(
+            r#"
+enum Foo <|>{
+    A,
+    B,
+}
+fn main() {
+    let f: Foo;
+    f = Foo::A;
+}
+"#,
+            expect![[r#"
+                Foo ENUM FileId(0) 0..26 5..8 Other
+
+                FileId(0) 63..66 EnumLiteral
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_enum_before_space() {
+        check(
+            r#"
+enum Foo<|> {
+    A,
+    B,
+}
+fn main() {
+    let f: Foo;
+    f = Foo::A;
+}
+"#,
+            expect![[r#"
+                Foo ENUM FileId(0) 0..26 5..8 Other
+
+                FileId(0) 50..53 Other
+                FileId(0) 63..66 EnumLiteral
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_enum_with_generic_type() {
+        check(
+            r#"
+enum Foo<T> <|>{
+    A(T),
+    B,
+}
+fn main() {
+    let f: Foo<i8>;
+    f = Foo::A(1);
+}
+"#,
+            expect![[r#"
+                Foo ENUM FileId(0) 0..32 5..8 Other
+
+                FileId(0) 73..76 EnumLiteral
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_enum_for_tuple() {
+        check(
+            r#"
+enum Foo<|>{
+    A(i8),
+    B(i8),
+}
+fn main() {
+    let f: Foo;
+    f = Foo::A(1);
+}
+"#,
+            expect![[r#"
+                Foo ENUM FileId(0) 0..33 5..8 Other
+
+                FileId(0) 70..73 EnumLiteral
+            "#]],
+        );
+    }
+
+    #[test]
     fn test_find_all_refs_for_local() {
         check(
             r#"
diff --git a/crates/ide_db/src/search.rs b/crates/ide_db/src/search.rs
index 607185ca9..3936c7390 100644
--- a/crates/ide_db/src/search.rs
+++ b/crates/ide_db/src/search.rs
@@ -32,6 +32,7 @@ pub enum ReferenceKind {
     StructLiteral,
     RecordFieldExprOrPat,
     SelfKw,
+    EnumLiteral,
     Other,
 }
 
@@ -284,6 +285,8 @@ impl<'a> FindUsages<'a> {
                     ReferenceKind::RecordFieldExprOrPat
                 } else if is_record_lit_name_ref(&name_ref) || is_call_expr_name_ref(&name_ref) {
                     ReferenceKind::StructLiteral
+                } else if is_enum_lit_name_ref(&name_ref) {
+                    ReferenceKind::EnumLiteral
                 } else {
                     ReferenceKind::Other
                 };
@@ -402,3 +405,15 @@ fn is_record_field_expr_or_pat(name_ref: &ast::NameRef) -> bool {
         false
     }
 }
+
+fn is_enum_lit_name_ref(name_ref: &ast::NameRef) -> bool {
+    name_ref
+        .syntax()
+        .ancestors()
+        .find_map(ast::PathExpr::cast)
+        .and_then(|p| p.path())
+        .and_then(|p| p.qualifier())
+        .and_then(|p| p.segment())
+        .map(|p| p.name_ref().as_ref() == Some(name_ref))
+        .unwrap_or(false)
+}
diff --git a/crates/proc_macro_srv/Cargo.toml b/crates/proc_macro_srv/Cargo.toml
index 729372968..1bfa6c3fc 100644
--- a/crates/proc_macro_srv/Cargo.toml
+++ b/crates/proc_macro_srv/Cargo.toml
@@ -10,7 +10,7 @@ edition = "2018"
 doctest = false
 
 [dependencies]
-goblin = "0.2.1"
+object = { version = "0.23", default-features = false, features = ["std", "read_core", "elf", "macho", "pe", "unaligned"] }
 libloading = "0.6.0"
 memmap = "0.7"
 
diff --git a/crates/proc_macro_srv/src/dylib.rs b/crates/proc_macro_srv/src/dylib.rs
index f8f705da8..2afb973cc 100644
--- a/crates/proc_macro_srv/src/dylib.rs
+++ b/crates/proc_macro_srv/src/dylib.rs
@@ -1,14 +1,17 @@
 //! Handles dynamic library loading for proc macro
 
-use crate::{proc_macro::bridge, rustc_server::TokenStream};
-use std::fs::File;
-use std::path::{Path, PathBuf};
+use std::{
+    fs::File,
+    io,
+    path::{Path, PathBuf},
+};
 
-use goblin::{mach::Mach, Object};
 use libloading::Library;
 use memmap::Mmap;
+use object::Object;
 use proc_macro_api::ProcMacroKind;
-use std::io;
+
+use crate::{proc_macro::bridge, rustc_server::TokenStream};
 
 const NEW_REGISTRAR_SYMBOL: &str = "_rustc_proc_macro_decls_";
 
@@ -23,40 +26,26 @@ fn is_derive_registrar_symbol(symbol: &str) -> bool {
 fn find_registrar_symbol(file: &Path) -> io::Result<Option<String>> {
     let file = File::open(file)?;
     let buffer = unsafe { Mmap::map(&file)? };
-    let object = Object::parse(&buffer).map_err(invalid_data_err)?;
 
-    let name = match object {
-        Object::Elf(elf) => {
-            let symbols = elf.dynstrtab.to_vec().map_err(invalid_data_err)?;
-            symbols.into_iter().find(|s| is_derive_registrar_symbol(s)).map(&str::to_owned)
-        }
-        Object::PE(pe) => pe
-            .exports
-            .iter()
-            .flat_map(|s| s.name)
-            .find(|s| is_derive_registrar_symbol(s))
-            .map(&str::to_owned),
-        Object::Mach(Mach::Binary(binary)) => {
-            let exports = binary.exports().map_err(invalid_data_err)?;
-            exports
-                .iter()
-                .map(|s| {
-                    // In macos doc:
-                    // https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man3/dlsym.3.html
-                    // Unlike other dyld API's, the symbol name passed to dlsym() must NOT be
-                    // prepended with an underscore.
-                    if s.name.starts_with('_') {
-                        &s.name[1..]
-                    } else {
-                        &s.name
-                    }
-                })
-                .find(|s| is_derive_registrar_symbol(s))
-                .map(&str::to_owned)
-        }
-        _ => return Ok(None),
-    };
-    return Ok(name);
+    Ok(object::File::parse(&buffer)
+        .map_err(invalid_data_err)?
+        .exports()
+        .map_err(invalid_data_err)?
+        .into_iter()
+        .map(|export| export.name())
+        .filter_map(|sym| String::from_utf8(sym.into()).ok())
+        .find(|sym| is_derive_registrar_symbol(sym))
+        .map(|sym| {
+            // From MacOS docs:
+            // https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man3/dlsym.3.html
+            // Unlike other dyld API's, the symbol name passed to dlsym() must NOT be
+            // prepended with an underscore.
+            if cfg!(target_os = "macos") && sym.starts_with('_') {
+                sym[1..].to_owned()
+            } else {
+                sym
+            }
+        }))
 }
 
 /// Loads dynamic library in platform dependent manner.