19 files changed, 399 insertions, 183 deletions

diff --git a/Cargo.lock b/Cargo.lock
index 8cb5fd7ad..ec8ad11cb 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -89,7 +89,7 @@ dependencies = [
  "cfg-if 1.0.0",
  "libc",
  "miniz_oxide",
- "object",
+ "object 0.22.0",
  "rustc-demangle",
 ]
 
@@ -500,17 +500,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f6503fe142514ca4799d4c26297c4248239fe8838d827db6bd6065c6ed29a6ce"
 
 [[package]]
-name = "goblin"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d20fd25aa456527ce4f544271ae4fea65d2eda4a6561ea56f39fb3ee4f7e3884"
-dependencies = [
- "log",
- "plain",
- "scroll",
-]
-
-[[package]]
 name = "hashbrown"
 version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1055,6 +1044,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8d3b63360ec3cb337817c2dbd47ab4a0f170d285d8e5a2064600f3def1402397"
 
 [[package]]
+name = "object"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9a7ab5d64814df0fe4a4b5ead45ed6c5f181ee3ff04ba344313a6c80446c5d4"
+
+[[package]]
 name = "once_cell"
 version = "1.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1159,12 +1154,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6b063f57ec186e6140e2b8b6921e5f1bd89c7356dda5b33acc5401203ca6131c"
 
 [[package]]
-name = "plain"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
-
-[[package]]
 name = "proc-macro2"
 version = "1.0.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1192,10 +1181,10 @@ version = "0.0.0"
 dependencies = [
  "cargo_metadata",
  "difference",
- "goblin",
  "libloading",
  "mbe",
  "memmap",
+ "object 0.23.0",
  "proc_macro_api",
  "proc_macro_test",
  "serde_derive",
@@ -1472,26 +1461,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
 
 [[package]]
-name = "scroll"
-version = "0.10.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fda28d4b4830b807a8b43f7b0e6b5df875311b3e7621d84577188c175b6ec1ec"
-dependencies = [
- "scroll_derive",
-]
-
-[[package]]
-name = "scroll_derive"
-version = "0.10.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b12bd20b94c7cdfda8c7ba9b92ad0d9a56e3fa018c25fca83b51aa664c9b4c0d"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
 name = "semver"
 version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
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.
diff --git a/docs/dev/style.md b/docs/dev/style.md
index c8d943142..13c6a2a16 100644
--- a/docs/dev/style.md
+++ b/docs/dev/style.md
@@ -96,19 +96,19 @@ When using multiline fixtures, use unindented raw string literals:
     fn inline_field_shorthand() {
         check_assist(
             inline_local_variable,
-            r"
+            r#"
 struct S { foo: i32}
 fn main() {
     let <|>foo = 92;
     S { foo }
 }
-",
-            r"
+"#,
+            r#"
 struct S { foo: i32}
 fn main() {
     S { foo: 92 }
 }
-",
+"#,
         );
     }
 ```
diff --git a/docs/user/manual.adoc b/docs/user/manual.adoc
index 42317b231..1ec6e81bb 100644
--- a/docs/user/manual.adoc
+++ b/docs/user/manual.adoc
@@ -289,6 +289,8 @@ GNOME Builder 3.37.1 and newer has native `rust-analyzer` support. If the LSP bi
 
 == Configuration
 
+**Source:** https://github.com/rust-analyzer/rust-analyzer/blob/master/crates/rust-analyzer/src/config.rs[config.rs]
+
 rust-analyzer is configured via LSP messages, which means that it's up to the editor to decide on the exact format and location of configuration files.
 Please consult your editor's documentation to learn how to configure LSP servers.
 
diff --git a/editors/code/.vscodeignore b/editors/code/.vscodeignore
index 7149ab799..5096ce4da 100644
--- a/editors/code/.vscodeignore
+++ b/editors/code/.vscodeignore
@@ -1,4 +1,5 @@
 **
+!language-configuration.json
 !out/src/main.js
 !package.json
 !package-lock.json