33 files changed, 728 insertions, 207 deletions

diff --git a/crates/assists/src/handlers/replace_qualified_name_with_use.rs b/crates/assists/src/handlers/replace_qualified_name_with_use.rs
index 8bdf9eea5..8193e45a8 100644
--- a/crates/assists/src/handlers/replace_qualified_name_with_use.rs
+++ b/crates/assists/src/handlers/replace_qualified_name_with_use.rs
@@ -407,7 +407,7 @@ impl std::fmt::Display<|> for Foo {
 }
 ",
             r"
-use std::fmt::{nested::Debug, Display};
+use std::fmt::{Display, nested::Debug};
 
 impl Display for Foo {
 }
diff --git a/crates/assists/src/handlers/ignore_test.rs b/crates/assists/src/handlers/toggle_ignore.rs
index 5096a0005..14b420421 100644
--- a/crates/assists/src/handlers/ignore_test.rs
+++ b/crates/assists/src/handlers/toggle_ignore.rs
@@ -5,7 +5,7 @@ use syntax::{
 
 use crate::{utils::test_related_attribute, AssistContext, AssistId, AssistKind, Assists};
 
-// Assist: ignore_test
+// Assist: toggle_ignore
 //
 // Adds `#[ignore]` attribute to the test.
 //
@@ -23,20 +23,20 @@ use crate::{utils::test_related_attribute, AssistContext, AssistId, AssistKind,
 //     assert_eq!(2 + 2, 5);
 // }
 // ```
-pub(crate) fn ignore_test(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+pub(crate) fn toggle_ignore(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
     let attr: ast::Attr = ctx.find_node_at_offset()?;
     let func = attr.syntax().parent().and_then(ast::Fn::cast)?;
     let attr = test_related_attribute(&func)?;
 
     match has_ignore_attribute(&func) {
         None => acc.add(
-            AssistId("ignore_test", AssistKind::None),
+            AssistId("toggle_ignore", AssistKind::None),
             "Ignore this test",
             attr.syntax().text_range(),
             |builder| builder.insert(attr.syntax().text_range().end(), &format!("\n#[ignore]")),
         ),
         Some(ignore_attr) => acc.add(
-            AssistId("unignore_test", AssistKind::None),
+            AssistId("toggle_ignore", AssistKind::None),
             "Re-enable this test",
             ignore_attr.syntax().text_range(),
             |builder| {
@@ -55,24 +55,19 @@ pub(crate) fn ignore_test(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
 }
 
 fn has_ignore_attribute(fn_def: &ast::Fn) -> Option<ast::Attr> {
-    fn_def.attrs().find_map(|attr| {
-        if attr.path()?.syntax().text() == "ignore" {
-            Some(attr)
-        } else {
-            None
-        }
-    })
+    fn_def.attrs().find(|attr| attr.path().map(|it| it.syntax().text() == "ignore") == Some(true))
 }
 
 #[cfg(test)]
 mod tests {
-    use super::ignore_test;
     use crate::tests::check_assist;
 
+    use super::*;
+
     #[test]
     fn test_base_case() {
         check_assist(
-            ignore_test,
+            toggle_ignore,
             r#"
             #[test<|>]
             fn test() {}
@@ -88,7 +83,7 @@ mod tests {
     #[test]
     fn test_unignore() {
         check_assist(
-            ignore_test,
+            toggle_ignore,
             r#"
             #[test<|>]
             #[ignore]
diff --git a/crates/assists/src/lib.rs b/crates/assists/src/lib.rs
index 17e9312db..dfe6c2729 100644
--- a/crates/assists/src/lib.rs
+++ b/crates/assists/src/lib.rs
@@ -141,7 +141,6 @@ mod handlers {
     mod generate_function;
     mod generate_impl;
     mod generate_new;
-    mod ignore_test;
     mod infer_function_return_type;
     mod inline_local_variable;
     mod introduce_named_lifetime;
@@ -164,6 +163,7 @@ mod handlers {
     mod replace_string_with_char;
     mod replace_unwrap_with_match;
     mod split_import;
+    mod toggle_ignore;
     mod unwrap_block;
     mod wrap_return_type_in_result;
 
@@ -190,7 +190,6 @@ mod handlers {
             generate_function::generate_function,
             generate_impl::generate_impl,
             generate_new::generate_new,
-            ignore_test::ignore_test,
             infer_function_return_type::infer_function_return_type,
             inline_local_variable::inline_local_variable,
             introduce_named_lifetime::introduce_named_lifetime,
@@ -215,6 +214,7 @@ mod handlers {
             replace_qualified_name_with_use::replace_qualified_name_with_use,
             replace_unwrap_with_match::replace_unwrap_with_match,
             split_import::split_import,
+            toggle_ignore::toggle_ignore,
             unwrap_block::unwrap_block,
             wrap_return_type_in_result::wrap_return_type_in_result,
             // These are manually sorted for better priorities
diff --git a/crates/assists/src/tests/generated.rs b/crates/assists/src/tests/generated.rs
index 5a9d1a01b..8d50c8791 100644
--- a/crates/assists/src/tests/generated.rs
+++ b/crates/assists/src/tests/generated.rs
@@ -474,26 +474,6 @@ impl<T: Clone> Ctx<T> {
 }
 
 #[test]
-fn doctest_ignore_test() {
-    check_doc_test(
-        "ignore_test",
-        r#####"
-<|>#[test]
-fn arithmetics {
-    assert_eq!(2 + 2, 5);
-}
-"#####,
-        r#####"
-#[test]
-#[ignore]
-fn arithmetics {
-    assert_eq!(2 + 2, 5);
-}
-"#####,
-    )
-}
-
-#[test]
 fn doctest_infer_function_return_type() {
     check_doc_test(
         "infer_function_return_type",
@@ -979,6 +959,26 @@ use std::{collections::HashMap};
 }
 
 #[test]
+fn doctest_toggle_ignore() {
+    check_doc_test(
+        "toggle_ignore",
+        r#####"
+<|>#[test]
+fn arithmetics {
+    assert_eq!(2 + 2, 5);
+}
+"#####,
+        r#####"
+#[test]
+#[ignore]
+fn arithmetics {
+    assert_eq!(2 + 2, 5);
+}
+"#####,
+    )
+}
+
+#[test]
 fn doctest_unwrap_block() {
     check_doc_test(
         "unwrap_block",
diff --git a/crates/completion/src/completions/postfix.rs b/crates/completion/src/completions/postfix.rs
index 7fbda7a6b..c8ba63cd3 100644
--- a/crates/completion/src/completions/postfix.rs
+++ b/crates/completion/src/completions/postfix.rs
@@ -5,6 +5,7 @@ mod format_like;
 use ide_db::ty_filter::TryEnum;
 use syntax::{
     ast::{self, AstNode, AstToken},
+    SyntaxKind::{BLOCK_EXPR, EXPR_STMT},
     TextRange, TextSize,
 };
 use text_edit::TextEdit;
@@ -220,6 +221,29 @@ pub(crate) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
     )
     .add_to(acc);
 
+    if let Some(parent) = dot_receiver.syntax().parent().and_then(|p| p.parent()) {
+        if matches!(parent.kind(), BLOCK_EXPR | EXPR_STMT) {
+            postfix_snippet(
+                ctx,
+                cap,
+                &dot_receiver,
+                "let",
+                "let",
+                &format!("let $0 = {};", receiver_text),
+            )
+            .add_to(acc);
+            postfix_snippet(
+                ctx,
+                cap,
+                &dot_receiver,
+                "letm",
+                "let mut",
+                &format!("let mut $0 = {};", receiver_text),
+            )
+            .add_to(acc);
+        }
+    }
+
     if let ast::Expr::Literal(literal) = dot_receiver.clone() {
         if let Some(literal_text) = ast::String::cast(literal.token()) {
             add_format_like_completions(acc, ctx, &dot_receiver, cap, &literal_text);
@@ -296,6 +320,38 @@ fn main() {
                 sn dbg   dbg!(expr)
                 sn dbgr  dbg!(&expr)
                 sn if    if expr {}
+                sn let   let
+                sn letm  let mut
+                sn match match expr {}
+                sn not   !expr
+                sn ok    Ok(expr)
+                sn ref   &expr
+                sn refm  &mut expr
+                sn some  Some(expr)
+                sn while while expr {}
+            "#]],
+        );
+    }
+
+    #[test]
+    fn postfix_completion_works_for_function_calln() {
+        check(
+            r#"
+fn foo(elt: bool) -> bool {
+    !elt
+}
+
+fn main() {
+    let bar = true;
+    foo(bar.<|>)
+}
+"#,
+            expect![[r#"
+                sn box   Box::new(expr)
+                sn call  function(expr)
+                sn dbg   dbg!(expr)
+                sn dbgr  dbg!(&expr)
+                sn if    if expr {}
                 sn match match expr {}
                 sn not   !expr
                 sn ok    Ok(expr)
@@ -321,6 +377,8 @@ fn main() {
                 sn call  function(expr)
                 sn dbg   dbg!(expr)
                 sn dbgr  dbg!(&expr)
+                sn let   let
+                sn letm  let mut
                 sn match match expr {}
                 sn ok    Ok(expr)
                 sn ref   &expr
@@ -331,6 +389,34 @@ fn main() {
     }
 
     #[test]
+    fn let_middle_block() {
+        check(
+            r#"
+fn main() {
+    baz.l<|>
+    res
+}
+"#,
+            expect![[r#"
+                sn box   Box::new(expr)
+                sn call  function(expr)
+                sn dbg   dbg!(expr)
+                sn dbgr  dbg!(&expr)
+                sn if    if expr {}
+                sn let   let
+                sn letm  let mut
+                sn match match expr {}
+                sn not   !expr
+                sn ok    Ok(expr)
+                sn ref   &expr
+                sn refm  &mut expr
+                sn some  Some(expr)
+                sn while while expr {}
+            "#]],
+        );
+    }
+
+    #[test]
     fn option_iflet() {
         check_edit(
             "ifl",
diff --git a/crates/completion/src/completions/qualified_path.rs b/crates/completion/src/completions/qualified_path.rs
index d9387054d..bc23bea3f 100644
--- a/crates/completion/src/completions/qualified_path.rs
+++ b/crates/completion/src/completions/qualified_path.rs
@@ -353,10 +353,10 @@ impl S {
 fn foo() { let _ = S::<|> }
 "#,
             expect![[r#"
-                ct C   const C: i32 = 42;
-                ta T   type T = i32;
-                fn a() fn a()
-                me b() fn b(&self)
+                ct C    const C: i32 = 42;
+                ta T    type T = i32;
+                fn a()  fn a()
+                me b(…) fn b(&self)
             "#]],
         );
     }
@@ -503,14 +503,14 @@ trait Sub: Super {
 fn foo<T: Sub>() { T::<|> }
 "#,
             expect![[r#"
-                ct C2          const C2: ();
-                ct CONST       const CONST: u8;
-                ta SubTy       type SubTy;
-                ta Ty          type Ty;
-                fn func()      fn func()
-                me method()    fn method(&self)
-                fn subfunc()   fn subfunc()
-                me submethod() fn submethod(&self)
+                ct C2           const C2: ();
+                ct CONST        const CONST: u8;
+                ta SubTy        type SubTy;
+                ta Ty           type Ty;
+                fn func()       fn func()
+                me method(…)    fn method(&self)
+                fn subfunc()    fn subfunc()
+                me submethod(…) fn submethod(&self)
             "#]],
         );
     }
@@ -543,14 +543,14 @@ impl<T> Sub for Wrap<T> {
 }
 "#,
             expect![[r#"
-                ct C2          const C2: () = ();
-                ct CONST       const CONST: u8 = 0;
-                ta SubTy       type SubTy;
-                ta Ty          type Ty;
-                fn func()      fn func()
-                me method()    fn method(&self)
-                fn subfunc()   fn subfunc()
-                me submethod() fn submethod(&self)
+                ct C2           const C2: () = ();
+                ct CONST        const CONST: u8 = 0;
+                ta SubTy        type SubTy;
+                ta Ty           type Ty;
+                fn func()       fn func()
+                me method(…)    fn method(&self)
+                fn subfunc()    fn subfunc()
+                me submethod(…) fn submethod(&self)
             "#]],
         );
     }
diff --git a/crates/completion/src/completions/trait_impl.rs b/crates/completion/src/completions/trait_impl.rs
index a14be9c73..e2fe44aff 100644
--- a/crates/completion/src/completions/trait_impl.rs
+++ b/crates/completion/src/completions/trait_impl.rs
@@ -139,7 +139,7 @@ fn add_function_impl(
 ) {
     let fn_name = func.name(ctx.db).to_string();
 
-    let label = if func.params(ctx.db).is_empty() {
+    let label = if func.assoc_fn_params(ctx.db).is_empty() {
         format!("fn {}()", fn_name)
     } else {
         format!("fn {}(..)", fn_name)
diff --git a/crates/completion/src/lib.rs b/crates/completion/src/lib.rs
index aecc1378b..1ec2e9be7 100644
--- a/crates/completion/src/lib.rs
+++ b/crates/completion/src/lib.rs
@@ -44,6 +44,8 @@ pub use crate::{
 // - `expr.while` -> `while expr {}` or `while let ... {}` for `Option` or `Result`
 // - `expr.ref` -> `&expr`
 // - `expr.refm` -> `&mut expr`
+// - `expr.let` -> `let <|> = expr;`
+// - `expr.letm` -> `let mut <|> = expr;`
 // - `expr.not` -> `!expr`
 // - `expr.dbg` -> `dbg!(expr)`
 // - `expr.dbgr` -> `dbg!(&expr)`
diff --git a/crates/completion/src/render/builder_ext.rs b/crates/completion/src/render/builder_ext.rs
index 37b0d0459..ce8718bd5 100644
--- a/crates/completion/src/render/builder_ext.rs
+++ b/crates/completion/src/render/builder_ext.rs
@@ -5,6 +5,7 @@ use test_utils::mark;
 
 use crate::{item::Builder, CompletionContext};
 
+#[derive(Debug)]
 pub(super) enum Params {
     Named(Vec<String>),
     Anonymous(usize),
@@ -24,7 +25,7 @@ impl Params {
 }
 
 impl Builder {
-    pub(super) fn should_add_parems(&self, ctx: &CompletionContext) -> bool {
+    fn should_add_parens(&self, ctx: &CompletionContext) -> bool {
         if !ctx.config.add_call_parenthesis {
             return false;
         }
@@ -58,7 +59,7 @@ impl Builder {
         name: String,
         params: Params,
     ) -> Builder {
-        if !self.should_add_parems(ctx) {
+        if !self.should_add_parens(ctx) {
             return self;
         }
 
diff --git a/crates/completion/src/render/function.rs b/crates/completion/src/render/function.rs
index 542383d7e..00e3eb203 100644
--- a/crates/completion/src/render/function.rs
+++ b/crates/completion/src/render/function.rs
@@ -2,6 +2,7 @@
 
 use hir::{HasSource, Type};
 use syntax::{ast::Fn, display::function_declaration};
+use test_utils::mark;
 
 use crate::{
     item::{CompletionItem, CompletionItemKind, CompletionKind, ImportToAdd},
@@ -22,7 +23,7 @@ pub(crate) fn render_fn<'a>(
 struct FunctionRender<'a> {
     ctx: RenderContext<'a>,
     name: String,
-    fn_: hir::Function,
+    func: hir::Function,
     ast_node: Fn,
 }
 
@@ -35,15 +36,15 @@ impl<'a> FunctionRender<'a> {
         let name = local_name.unwrap_or_else(|| fn_.name(ctx.db()).to_string());
         let ast_node = fn_.source(ctx.db()).value;
 
-        FunctionRender { ctx, name, fn_, ast_node }
+        FunctionRender { ctx, name, func: fn_, ast_node }
     }
 
     fn render(self, import_to_add: Option<ImportToAdd>) -> CompletionItem {
         let params = self.params();
         CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), self.name.clone())
             .kind(self.kind())
-            .set_documentation(self.ctx.docs(self.fn_))
-            .set_deprecated(self.ctx.is_deprecated(self.fn_))
+            .set_documentation(self.ctx.docs(self.func))
+            .set_deprecated(self.ctx.is_deprecated(self.func))
             .detail(self.detail())
             .add_call_parens(self.ctx.completion, self.name, params)
             .add_import(import_to_add)
@@ -67,27 +68,39 @@ impl<'a> FunctionRender<'a> {
     }
 
     fn params(&self) -> Params {
-        let params_ty = self.fn_.params(self.ctx.db());
-        let params = self
-            .ast_node
-            .param_list()
+        let ast_params = match self.ast_node.param_list() {
+            Some(it) => it,
+            None => return Params::Named(Vec::new()),
+        };
+
+        let mut params_pats = Vec::new();
+        let params_ty = if self.ctx.completion.dot_receiver.is_some() {
+            self.func.method_params(self.ctx.db()).unwrap_or_default()
+        } else {
+            if let Some(s) = ast_params.self_param() {
+                mark::hit!(parens_for_method_call_as_assoc_fn);
+                params_pats.push(Some(s.to_string()));
+            }
+            self.func.assoc_fn_params(self.ctx.db())
+        };
+        params_pats
+            .extend(ast_params.params().into_iter().map(|it| it.pat().map(|it| it.to_string())));
+
+        let params = params_pats
             .into_iter()
-            .flat_map(|it| it.params())
             .zip(params_ty)
-            .flat_map(|(it, param_ty)| {
-                if let Some(pat) = it.pat() {
-                    let name = pat.to_string();
-                    let arg = name.trim_start_matches("mut ").trim_start_matches('_');
-                    return Some(self.add_arg(arg, param_ty.ty()));
-                }
-                None
+            .flat_map(|(pat, param_ty)| {
+                let pat = pat?;
+                let name = pat.to_string();
+                let arg = name.trim_start_matches("mut ").trim_start_matches('_');
+                Some(self.add_arg(arg, param_ty.ty()))
             })
             .collect();
         Params::Named(params)
     }
 
     fn kind(&self) -> CompletionItemKind {
-        if self.fn_.self_param(self.ctx.db()).is_some() {
+        if self.func.self_param(self.ctx.db()).is_some() {
             CompletionItemKind::Method
         } else {
             CompletionItemKind::Function
@@ -173,6 +186,28 @@ fn bar(s: &S) {
     }
 
     #[test]
+    fn parens_for_method_call_as_assoc_fn() {
+        mark::check!(parens_for_method_call_as_assoc_fn);
+        check_edit(
+            "foo",
+            r#"
+struct S;
+impl S {
+    fn foo(&self) {}
+}
+fn main() { S::f<|> }
+"#,
+            r#"
+struct S;
+impl S {
+    fn foo(&self) {}
+}
+fn main() { S::foo(${1:&self})$0 }
+"#,
+        );
+    }
+
+    #[test]
     fn suppress_arg_snippets() {
         mark::check!(suppress_arg_snippets);
         check_edit_with_config(
diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index f06b5cd9f..4500050f1 100644
--- a/crates/hir/src/code_model.rs
+++ b/crates/hir/src/code_model.rs
@@ -744,14 +744,13 @@ impl Function {
         Some(SelfParam { func: self.id })
     }
 
-    pub fn params(self, db: &dyn HirDatabase) -> Vec<Param> {
+    pub fn assoc_fn_params(self, db: &dyn HirDatabase) -> Vec<Param> {
         let resolver = self.id.resolver(db.upcast());
         let ctx = hir_ty::TyLoweringContext::new(db, &resolver);
         let environment = TraitEnvironment::lower(db, &resolver);
         db.function_data(self.id)
             .params
             .iter()
-            .skip(if self.self_param(db).is_some() { 1 } else { 0 })
             .map(|type_ref| {
                 let ty = Type {
                     krate: self.id.lookup(db.upcast()).container.module(db.upcast()).krate,
@@ -764,6 +763,14 @@ impl Function {
             })
             .collect()
     }
+    pub fn method_params(self, db: &dyn HirDatabase) -> Option<Vec<Param>> {
+        if self.self_param(db).is_none() {
+            return None;
+        }
+        let mut res = self.assoc_fn_params(db);
+        res.remove(0);
+        Some(res)
+    }
 
     pub fn is_unsafe(self, db: &dyn HirDatabase) -> bool {
         db.function_data(self.id).is_unsafe
@@ -799,6 +806,7 @@ impl From<Mutability> for Access {
     }
 }
 
+#[derive(Debug)]
 pub struct Param {
     ty: Type,
 }
diff --git a/crates/hir_def/src/body.rs b/crates/hir_def/src/body.rs
index d10b1af01..33eb5e78c 100644
--- a/crates/hir_def/src/body.rs
+++ b/crates/hir_def/src/body.rs
@@ -14,8 +14,8 @@ use cfg::CfgOptions;
 use drop_bomb::DropBomb;
 use either::Either;
 use hir_expand::{
-    ast_id_map::AstIdMap, diagnostics::DiagnosticSink, hygiene::Hygiene, AstId, HirFileId, InFile,
-    MacroDefId,
+    ast_id_map::AstIdMap, diagnostics::DiagnosticSink, hygiene::Hygiene, AstId, ExpandResult,
+    HirFileId, InFile, MacroDefId,
 };
 use rustc_hash::FxHashMap;
 use syntax::{ast, AstNode, AstPtr};
@@ -102,11 +102,11 @@ impl Expander {
         db: &dyn DefDatabase,
         local_scope: Option<&ItemScope>,
         macro_call: ast::MacroCall,
-    ) -> Option<(Mark, T)> {
+    ) -> ExpandResult<Option<(Mark, T)>> {
         self.recursion_limit += 1;
         if self.recursion_limit > EXPANSION_RECURSION_LIMIT {
             mark::hit!(your_stack_belongs_to_me);
-            return None;
+            return ExpandResult::str_err("reached recursion limit during macro expansion".into());
         }
 
         let macro_call = InFile::new(self.current_file_id, &macro_call);
@@ -120,28 +120,55 @@ impl Expander {
             self.resolve_path_as_macro(db, &path)
         };
 
-        if let Some(call_id) = macro_call.as_call_id(db, self.crate_def_map.krate, resolver) {
-            let file_id = call_id.as_file();
-            if let Some(node) = db.parse_or_expand(file_id) {
-                if let Some(expr) = T::cast(node) {
-                    log::debug!("macro expansion {:#?}", expr.syntax());
-
-                    let mark = Mark {
-                        file_id: self.current_file_id,
-                        ast_id_map: mem::take(&mut self.ast_id_map),
-                        bomb: DropBomb::new("expansion mark dropped"),
-                    };
-                    self.cfg_expander.hygiene = Hygiene::new(db.upcast(), file_id);
-                    self.current_file_id = file_id;
-                    self.ast_id_map = db.ast_id_map(file_id);
-                    return Some((mark, expr));
+        let call_id = match macro_call.as_call_id(db, self.crate_def_map.krate, resolver) {
+            Some(it) => it,
+            None => {
+                // FIXME: this can mean other things too, but `as_call_id` doesn't provide enough
+                // info.
+                return ExpandResult::only_err(mbe::ExpandError::Other(
+                    "failed to parse or resolve macro invocation".into(),
+                ));
+            }
+        };
+
+        let err = db.macro_expand_error(call_id);
+
+        let file_id = call_id.as_file();
+
+        let raw_node = match db.parse_or_expand(file_id) {
+            Some(it) => it,
+            None => {
+                // Only `None` if the macro expansion produced no usable AST.
+                if err.is_none() {
+                    log::warn!("no error despite `parse_or_expand` failing");
                 }
+
+                return ExpandResult::only_err(err.unwrap_or_else(|| {
+                    mbe::ExpandError::Other("failed to parse macro invocation".into())
+                }));
             }
-        }
+        };
+
+        let node = match T::cast(raw_node) {
+            Some(it) => it,
+            None => {
+                // This can happen without being an error, so only forward previous errors.
+                return ExpandResult { value: None, err };
+            }
+        };
+
+        log::debug!("macro expansion {:#?}", node.syntax());
+
+        let mark = Mark {
+            file_id: self.current_file_id,
+            ast_id_map: mem::take(&mut self.ast_id_map),
+            bomb: DropBomb::new("expansion mark dropped"),
+        };
+        self.cfg_expander.hygiene = Hygiene::new(db.upcast(), file_id);
+        self.current_file_id = file_id;
+        self.ast_id_map = db.ast_id_map(file_id);
 
-        // FIXME: Instead of just dropping the error from expansion
-        // report it
-        None
+        ExpandResult { value: Some((mark, node)), err }
     }
 
     pub(crate) fn exit(&mut self, db: &dyn DefDatabase, mut mark: Mark) {
diff --git a/crates/hir_def/src/body/diagnostics.rs b/crates/hir_def/src/body/diagnostics.rs
index e57bdc133..1de7d30e2 100644
--- a/crates/hir_def/src/body/diagnostics.rs
+++ b/crates/hir_def/src/body/diagnostics.rs
@@ -2,11 +2,13 @@
 
 use hir_expand::diagnostics::DiagnosticSink;
 
-use crate::diagnostics::InactiveCode;
+use crate::diagnostics::{InactiveCode, MacroError, UnresolvedProcMacro};
 
 #[derive(Debug, Eq, PartialEq)]
 pub(crate) enum BodyDiagnostic {
     InactiveCode(InactiveCode),
+    MacroError(MacroError),
+    UnresolvedProcMacro(UnresolvedProcMacro),
 }
 
 impl BodyDiagnostic {
@@ -15,6 +17,12 @@ impl BodyDiagnostic {
             BodyDiagnostic::InactiveCode(diag) => {
                 sink.push(diag.clone());
             }
+            BodyDiagnostic::MacroError(diag) => {
+                sink.push(diag.clone());
+            }
+            BodyDiagnostic::UnresolvedProcMacro(diag) => {
+                sink.push(diag.clone());
+            }
         }
     }
 }
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index cd7958746..2c41c0005 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -8,7 +8,7 @@ use either::Either;
 use hir_expand::{
     hygiene::Hygiene,
     name::{name, AsName, Name},
-    HirFileId, MacroDefId, MacroDefKind,
+    ExpandError, HirFileId, MacroDefId, MacroDefKind,
 };
 use rustc_hash::FxHashMap;
 use syntax::{
@@ -25,7 +25,7 @@ use crate::{
     body::{Body, BodySourceMap, Expander, PatPtr, SyntheticSyntax},
     builtin_type::{BuiltinFloat, BuiltinInt},
     db::DefDatabase,
-    diagnostics::InactiveCode,
+    diagnostics::{InactiveCode, MacroError, UnresolvedProcMacro},
     expr::{
         dummy_expr_id, ArithOp, Array, BinaryOp, BindingAnnotation, CmpOp, Expr, ExprId, Literal,
         LogicOp, MatchArm, Ordering, Pat, PatId, RecordFieldPat, RecordLitField, Statement,
@@ -561,7 +561,32 @@ impl ExprCollector<'_> {
                     self.alloc_expr(Expr::Missing, syntax_ptr)
                 } else {
                     let macro_call = self.expander.to_source(AstPtr::new(&e));
-                    match self.expander.enter_expand(self.db, Some(&self.body.item_scope), e) {
+                    let res = self.expander.enter_expand(self.db, Some(&self.body.item_scope), e);
+
+                    match res.err {
+                        Some(ExpandError::UnresolvedProcMacro) => {
+                            self.source_map.diagnostics.push(BodyDiagnostic::UnresolvedProcMacro(
+                                UnresolvedProcMacro {
+                                    file: self.expander.current_file_id,
+                                    node: syntax_ptr.clone().into(),
+                                    precise_location: None,
+                                    macro_name: None,
+                                },
+                            ));
+                        }
+                        Some(err) => {
+                            self.source_map.diagnostics.push(BodyDiagnostic::MacroError(
+                                MacroError {
+                                    file: self.expander.current_file_id,
+                                    node: syntax_ptr.clone().into(),
+                                    message: err.to_string(),
+                                },
+                            ));
+                        }
+                        None => {}
+                    }
+
+                    match res.value {
                         Some((mark, expansion)) => {
                             self.source_map
                                 .expansions
diff --git a/crates/hir_def/src/data.rs b/crates/hir_def/src/data.rs
index ff1ef0df6..146045938 100644
--- a/crates/hir_def/src/data.rs
+++ b/crates/hir_def/src/data.rs
@@ -257,7 +257,7 @@ fn collect_items(
                 let root = db.parse_or_expand(file_id).unwrap();
                 let call = ast_id_map.get(call.ast_id).to_node(&root);
 
-                if let Some((mark, mac)) = expander.enter_expand(db, None, call) {
+                if let Some((mark, mac)) = expander.enter_expand(db, None, call).value {
                     let src: InFile<ast::MacroItems> = expander.to_source(mac);
                     let item_tree = db.item_tree(src.file_id);
                     let iter =
diff --git a/crates/hir_def/src/nameres/tests/mod_resolution.rs b/crates/hir_def/src/nameres/tests/mod_resolution.rs
index ba295fd9e..ef6f85e15 100644
--- a/crates/hir_def/src/nameres/tests/mod_resolution.rs
+++ b/crates/hir_def/src/nameres/tests/mod_resolution.rs
@@ -798,3 +798,24 @@ mod foo;
 "#,
     );
 }
+
+#[test]
+fn abs_path_ignores_local() {
+    check(
+        r#"
+//- /main.rs crate:main deps:core
+pub use ::core::hash::Hash;
+pub mod core {}
+
+//- /lib.rs crate:core
+pub mod hash { pub trait Hash {} }
+"#,
+        expect![[r#"
+            crate
+            Hash: t
+            core: t
+
+            crate::core
+        "#]],
+    );
+}
diff --git a/crates/hir_def/src/path/lower/lower_use.rs b/crates/hir_def/src/path/lower/lower_use.rs
index 53cecb05f..ba0d1f0e7 100644
--- a/crates/hir_def/src/path/lower/lower_use.rs
+++ b/crates/hir_def/src/path/lower/lower_use.rs
@@ -76,7 +76,7 @@ fn convert_path(prefix: Option<ModPath>, path: ast::Path, hygiene: &Hygiene) ->
                 Either::Left(name) => {
                     // no type args in use
                     let mut res = prefix.unwrap_or_else(|| ModPath {
-                        kind: PathKind::Plain,
+                        kind: segment.coloncolon_token().map_or(PathKind::Plain, |_| PathKind::Abs),
                         segments: Vec::with_capacity(1),
                     });
                     res.segments.push(name);
diff --git a/crates/hir_expand/src/builtin_macro.rs b/crates/hir_expand/src/builtin_macro.rs
index aebbfc4df..7f4db106d 100644
--- a/crates/hir_expand/src/builtin_macro.rs
+++ b/crates/hir_expand/src/builtin_macro.rs
@@ -6,7 +6,7 @@ use crate::{
 
 use base_db::FileId;
 use either::Either;
-use mbe::parse_to_token_tree;
+use mbe::{parse_to_token_tree, ExpandResult};
 use parser::FragmentKind;
 use syntax::ast::{self, AstToken};
 
@@ -28,7 +28,7 @@ macro_rules! register_builtin {
                 db: &dyn AstDatabase,
                 id: LazyMacroId,
                 tt: &tt::Subtree,
-            ) -> Result<tt::Subtree, mbe::ExpandError> {
+            ) -> ExpandResult<tt::Subtree> {
                 let expander = match *self {
                     $( BuiltinFnLikeExpander::$kind => $expand, )*
                 };
@@ -42,7 +42,7 @@ macro_rules! register_builtin {
                 db: &dyn AstDatabase,
                 arg_id: EagerMacroId,
                 tt: &tt::Subtree,
-            ) -> Result<(tt::Subtree, FragmentKind), mbe::ExpandError> {
+            ) -> ExpandResult<Option<(tt::Subtree, FragmentKind)>> {
                 let expander = match *self {
                     $( EagerExpander::$e_kind => $e_expand, )*
                 };
@@ -109,25 +109,28 @@ fn line_expand(
     _db: &dyn AstDatabase,
     _id: LazyMacroId,
     _tt: &tt::Subtree,
-) -> Result<tt::Subtree, mbe::ExpandError> {
+) -> ExpandResult<tt::Subtree> {
     // dummy implementation for type-checking purposes
     let line_num = 0;
     let expanded = quote! {
         #line_num
     };
 
-    Ok(expanded)
+    ExpandResult::ok(expanded)
 }
 
 fn stringify_expand(
     db: &dyn AstDatabase,
     id: LazyMacroId,
     _tt: &tt::Subtree,
-) -> Result<tt::Subtree, mbe::ExpandError> {
+) -> ExpandResult<tt::Subtree> {
     let loc = db.lookup_intern_macro(id);
 
     let macro_content = {
-        let arg = loc.kind.arg(db).ok_or_else(|| mbe::ExpandError::UnexpectedToken)?;
+        let arg = match loc.kind.arg(db) {
+            Some(arg) => arg,
+            None => return ExpandResult::only_err(mbe::ExpandError::UnexpectedToken),
+        };
         let macro_args = arg;
         let text = macro_args.text();
         let without_parens = TextSize::of('(')..text.len() - TextSize::of(')');
@@ -138,28 +141,28 @@ fn stringify_expand(
         #macro_content
     };
 
-    Ok(expanded)
+    ExpandResult::ok(expanded)
 }
 
 fn column_expand(
     _db: &dyn AstDatabase,
     _id: LazyMacroId,
     _tt: &tt::Subtree,
-) -> Result<tt::Subtree, mbe::ExpandError> {
+) -> ExpandResult<tt::Subtree> {
     // dummy implementation for type-checking purposes
     let col_num = 0;
     let expanded = quote! {
         #col_num
     };
 
-    Ok(expanded)
+    ExpandResult::ok(expanded)
 }
 
 fn assert_expand(
     _db: &dyn AstDatabase,
     _id: LazyMacroId,
     tt: &tt::Subtree,
-) -> Result<tt::Subtree, mbe::ExpandError> {
+) -> ExpandResult<tt::Subtree> {
     // A hacky implementation for goto def and hover
     // We expand `assert!(cond, arg1, arg2)` to
     // ```
@@ -191,14 +194,14 @@ fn assert_expand(
     let expanded = quote! {
         { { (##arg_tts); } }
     };
-    Ok(expanded)
+    ExpandResult::ok(expanded)
 }
 
 fn file_expand(
     _db: &dyn AstDatabase,
     _id: LazyMacroId,
     _tt: &tt::Subtree,
-) -> Result<tt::Subtree, mbe::ExpandError> {
+) -> ExpandResult<tt::Subtree> {
     // FIXME: RA purposefully lacks knowledge of absolute file names
     // so just return "".
     let file_name = "";
@@ -207,31 +210,33 @@ fn file_expand(
         #file_name
     };
 
-    Ok(expanded)
+    ExpandResult::ok(expanded)
 }
 
 fn compile_error_expand(
     _db: &dyn AstDatabase,
     _id: LazyMacroId,
     tt: &tt::Subtree,
-) -> Result<tt::Subtree, mbe::ExpandError> {
+) -> ExpandResult<tt::Subtree> {
     if tt.count() == 1 {
         if let tt::TokenTree::Leaf(tt::Leaf::Literal(it)) = &tt.token_trees[0] {
             let s = it.text.as_str();
             if s.contains('"') {
-                return Ok(quote! { loop { #it }});
+                return ExpandResult::ok(quote! { loop { #it }});
             }
         };
     }
 
-    Err(mbe::ExpandError::BindingError("Must be a string".into()))
+    ExpandResult::only_err(mbe::ExpandError::BindingError(
+        "`compile_error!` argument be a string".into(),
+    ))
 }
 
 fn format_args_expand(
     _db: &dyn AstDatabase,
     _id: LazyMacroId,
     tt: &tt::Subtree,
-) -> Result<tt::Subtree, mbe::ExpandError> {
+) -> ExpandResult<tt::Subtree> {
     // We expand `format_args!("", a1, a2)` to
     // ```
     // std::fmt::Arguments::new_v1(&[], &[
@@ -257,7 +262,7 @@ fn format_args_expand(
         args.push(current);
     }
     if args.is_empty() {
-        return Err(mbe::ExpandError::NoMatchingRule);
+        return ExpandResult::only_err(mbe::ExpandError::NoMatchingRule);
     }
     let _format_string = args.remove(0);
     let arg_tts = args.into_iter().flat_map(|arg| {
@@ -266,7 +271,7 @@ fn format_args_expand(
     let expanded = quote! {
         std::fmt::Arguments::new_v1(&[], &[##arg_tts])
     };
-    Ok(expanded)
+    ExpandResult::ok(expanded)
 }
 
 fn unquote_str(lit: &tt::Literal) -> Option<String> {
@@ -279,19 +284,24 @@ fn concat_expand(
     _db: &dyn AstDatabase,
     _arg_id: EagerMacroId,
     tt: &tt::Subtree,
-) -> Result<(tt::Subtree, FragmentKind), mbe::ExpandError> {
+) -> ExpandResult<Option<(tt::Subtree, FragmentKind)>> {
     let mut text = String::new();
     for (i, t) in tt.token_trees.iter().enumerate() {
         match t {
             tt::TokenTree::Leaf(tt::Leaf::Literal(it)) if i % 2 == 0 => {
-                text += &unquote_str(&it).ok_or_else(|| mbe::ExpandError::ConversionError)?;
+                text += &match unquote_str(&it) {
+                    Some(s) => s,
+                    None => {
+                        return ExpandResult::only_err(mbe::ExpandError::ConversionError);
+                    }
+                };
             }
             tt::TokenTree::Leaf(tt::Leaf::Punct(punct)) if i % 2 == 1 && punct.char == ',' => (),
-            _ => return Err(mbe::ExpandError::UnexpectedToken),
+            _ => return ExpandResult::only_err(mbe::ExpandError::UnexpectedToken),
         }
     }
 
-    Ok((quote!(#text), FragmentKind::Expr))
+    ExpandResult::ok(Some((quote!(#text), FragmentKind::Expr)))
 }
 
 fn relative_file(
@@ -324,26 +334,35 @@ fn include_expand(
     db: &dyn AstDatabase,
     arg_id: EagerMacroId,
     tt: &tt::Subtree,
-) -> Result<(tt::Subtree, FragmentKind), mbe::ExpandError> {
-    let path = parse_string(tt)?;
-    let file_id = relative_file(db, arg_id.into(), &path, false)
-        .ok_or_else(|| mbe::ExpandError::ConversionError)?;
-
-    // FIXME:
-    // Handle include as expression
-    let res = parse_to_token_tree(&db.file_text(file_id))
-        .ok_or_else(|| mbe::ExpandError::ConversionError)?
-        .0;
-
-    Ok((res, FragmentKind::Items))
+) -> ExpandResult<Option<(tt::Subtree, FragmentKind)>> {
+    let res = (|| {
+        let path = parse_string(tt)?;
+        let file_id = relative_file(db, arg_id.into(), &path, false)
+            .ok_or_else(|| mbe::ExpandError::ConversionError)?;
+
+        Ok(parse_to_token_tree(&db.file_text(file_id))
+            .ok_or_else(|| mbe::ExpandError::ConversionError)?
+            .0)
+    })();
+
+    match res {
+        Ok(res) => {
+            // FIXME:
+            // Handle include as expression
+            ExpandResult::ok(Some((res, FragmentKind::Items)))
+        }
+        Err(e) => ExpandResult::only_err(e),
+    }
 }
 
 fn include_bytes_expand(
     _db: &dyn AstDatabase,
     _arg_id: EagerMacroId,
     tt: &tt::Subtree,
-) -> Result<(tt::Subtree, FragmentKind), mbe::ExpandError> {
-    let _path = parse_string(tt)?;
+) -> ExpandResult<Option<(tt::Subtree, FragmentKind)>> {
+    if let Err(e) = parse_string(tt) {
+        return ExpandResult::only_err(e);
+    }
 
     // FIXME: actually read the file here if the user asked for macro expansion
     let res = tt::Subtree {
@@ -353,15 +372,18 @@ fn include_bytes_expand(
             id: tt::TokenId::unspecified(),
         }))],
     };
-    Ok((res, FragmentKind::Expr))
+    ExpandResult::ok(Some((res, FragmentKind::Expr)))
 }
 
 fn include_str_expand(
     db: &dyn AstDatabase,
     arg_id: EagerMacroId,
     tt: &tt::Subtree,
-) -> Result<(tt::Subtree, FragmentKind), mbe::ExpandError> {
-    let path = parse_string(tt)?;
+) -> ExpandResult<Option<(tt::Subtree, FragmentKind)>> {
+    let path = match parse_string(tt) {
+        Ok(it) => it,
+        Err(e) => return ExpandResult::only_err(e),
+    };
 
     // FIXME: we're not able to read excluded files (which is most of them because
     // it's unusual to `include_str!` a Rust file), but we can return an empty string.
@@ -370,14 +392,14 @@ fn include_str_expand(
     let file_id = match relative_file(db, arg_id.into(), &path, true) {
         Some(file_id) => file_id,
         None => {
-            return Ok((quote!(""), FragmentKind::Expr));
+            return ExpandResult::ok(Some((quote!(""), FragmentKind::Expr)));
         }
     };
 
     let text = db.file_text(file_id);
     let text = &*text;
 
-    Ok((quote!(#text), FragmentKind::Expr))
+    ExpandResult::ok(Some((quote!(#text), FragmentKind::Expr)))
 }
 
 fn get_env_inner(db: &dyn AstDatabase, arg_id: EagerMacroId, key: &str) -> Option<String> {
@@ -389,8 +411,11 @@ fn env_expand(
     db: &dyn AstDatabase,
     arg_id: EagerMacroId,
     tt: &tt::Subtree,
-) -> Result<(tt::Subtree, FragmentKind), mbe::ExpandError> {
-    let key = parse_string(tt)?;
+) -> ExpandResult<Option<(tt::Subtree, FragmentKind)>> {
+    let key = match parse_string(tt) {
+        Ok(it) => it,
+        Err(e) => return ExpandResult::only_err(e),
+    };
 
     // FIXME:
     // If the environment variable is not defined int rustc, then a compilation error will be emitted.
@@ -402,21 +427,25 @@ fn env_expand(
     let s = get_env_inner(db, arg_id, &key).unwrap_or_else(|| "__RA_UNIMPLEMENTED__".to_string());
     let expanded = quote! { #s };
 
-    Ok((expanded, FragmentKind::Expr))
+    ExpandResult::ok(Some((expanded, FragmentKind::Expr)))
 }
 
 fn option_env_expand(
     db: &dyn AstDatabase,
     arg_id: EagerMacroId,
     tt: &tt::Subtree,
-) -> Result<(tt::Subtree, FragmentKind), mbe::ExpandError> {
-    let key = parse_string(tt)?;
+) -> ExpandResult<Option<(tt::Subtree, FragmentKind)>> {
+    let key = match parse_string(tt) {
+        Ok(it) => it,
+        Err(e) => return ExpandResult::only_err(e),
+    };
+
     let expanded = match get_env_inner(db, arg_id, &key) {
         None => quote! { std::option::Option::None::<&str> },
         Some(s) => quote! { std::option::Some(#s) },
     };
 
-    Ok((expanded, FragmentKind::Expr))
+    ExpandResult::ok(Some((expanded, FragmentKind::Expr)))
 }
 
 #[cfg(test)]
@@ -485,7 +514,7 @@ mod tests {
                     }
                 });
 
-                let (subtree, fragment) = expander.expand(&db, arg_id, &parsed_args).unwrap();
+                let (subtree, fragment) = expander.expand(&db, arg_id, &parsed_args).value.unwrap();
                 let eager = EagerCallLoc {
                     def,
                     fragment,
diff --git a/crates/hir_expand/src/db.rs b/crates/hir_expand/src/db.rs
index ff50bfd82..4fd0ba290 100644
--- a/crates/hir_expand/src/db.rs
+++ b/crates/hir_expand/src/db.rs
@@ -30,8 +30,8 @@ impl TokenExpander {
     ) -> mbe::ExpandResult<tt::Subtree> {
         match self {
             TokenExpander::MacroRules(it) => it.expand(tt),
+            TokenExpander::Builtin(it) => it.expand(db, id, tt),
             // FIXME switch these to ExpandResult as well
-            TokenExpander::Builtin(it) => it.expand(db, id, tt).into(),
             TokenExpander::BuiltinDerive(it) => it.expand(db, id, tt).into(),
             TokenExpander::ProcMacro(_) => {
                 // We store the result in salsa db to prevent non-determinisc behavior in
diff --git a/crates/hir_expand/src/eager.rs b/crates/hir_expand/src/eager.rs
index 2f37d7189..ab6b4477c 100644
--- a/crates/hir_expand/src/eager.rs
+++ b/crates/hir_expand/src/eager.rs
@@ -65,7 +65,7 @@ pub fn expand_eager_macro(
     let subtree = to_subtree(&result)?;
 
     if let MacroDefKind::BuiltInEager(eager) = def.kind {
-        let (subtree, fragment) = eager.expand(db, arg_id, &subtree).ok()?;
+        let (subtree, fragment) = eager.expand(db, arg_id, &subtree).value?;
         let eager = EagerCallLoc {
             def,
             fragment,
diff --git a/crates/ide/src/goto_definition.rs b/crates/ide/src/goto_definition.rs
index d41dd3d92..b9810457f 100644
--- a/crates/ide/src/goto_definition.rs
+++ b/crates/ide/src/goto_definition.rs
@@ -1,5 +1,6 @@
 use hir::Semantics;
 use ide_db::{
+    base_db::FileId,
     defs::{NameClass, NameRefClass},
     symbol_index, RootDatabase,
 };
@@ -40,10 +41,17 @@ pub(crate) fn goto_definition(
                 vec![nav]
             },
             ast::SelfParam(self_param) => {
-                let ty = sema.type_of_self(&self_param)?;
-                let adt_def = ty.autoderef(db).filter_map(|ty| ty.as_adt()).last()?;
-                let nav = adt_def.to_nav(db);
-                vec![nav]
+                vec![self_to_nav_target(self_param, position.file_id)?]
+            },
+            ast::PathSegment(segment) => {
+                segment.self_token()?;
+                let path = segment.parent_path();
+                if path.qualifier().is_some() && !ast::PathExpr::can_cast(path.syntax().parent()?.kind()) {
+                    return None;
+                }
+                let func = segment.syntax().ancestors().find_map(ast::Fn::cast)?;
+                let self_param = func.param_list()?.self_param()?;
+                vec![self_to_nav_target(self_param, position.file_id)?]
             },
             _ => return None,
         }
@@ -63,6 +71,20 @@ fn pick_best(tokens: TokenAtOffset<SyntaxToken>) -> Option<SyntaxToken> {
     }
 }
 
+fn self_to_nav_target(self_param: ast::SelfParam, file_id: FileId) -> Option<NavigationTarget> {
+    let self_token = self_param.self_token()?;
+    Some(NavigationTarget {
+        file_id,
+        full_range: self_param.syntax().text_range(),
+        focus_range: Some(self_token.text_range()),
+        name: self_token.text().clone(),
+        kind: self_token.kind(),
+        container_name: None,
+        description: None,
+        docs: None,
+    })
+}
+
 #[derive(Debug)]
 pub(crate) enum ReferenceResult {
     Exact(NavigationTarget),
@@ -987,31 +1009,31 @@ fn g() -> <() as Iterator<A = (), B<|> = u8>>::A {}
     }
 
     #[test]
-    fn todo_def_type_for_self() {
+    fn goto_self_param_ty_specified() {
         check(
             r#"
 struct Foo {}
-     //^^^
 
 impl Foo {
-    fn bar(&self<|>) {}
-}
-"#,
-        );
+    fn bar(self: &Foo) {
+         //^^^^
+        let foo = sel<|>f;
+    }
+}"#,
+        )
     }
 
     #[test]
-    fn todo_def_type_for_arbitrary_self() {
+    fn goto_self_param_on_decl() {
         check(
             r#"
-struct Arc<T>(T);
-     //^^^
 struct Foo {}
 
 impl Foo {
-    fn bar(self<|>: Arc<Self>) {}
-}
-"#,
-        );
+    fn bar(&self<|>) {
+          //^^^^
+    }
+}"#,
+        )
     }
 }
diff --git a/crates/ide/src/references.rs b/crates/ide/src/references.rs
index 5693dd400..7395b81bd 100644
--- a/crates/ide/src/references.rs
+++ b/crates/ide/src/references.rs
@@ -21,7 +21,7 @@ use ide_db::{
 use syntax::{
     algo::find_node_at_offset,
     ast::{self, NameOwner},
-    AstNode, SyntaxKind, SyntaxNode, TextRange, TokenAtOffset,
+    match_ast, AstNode, SyntaxKind, SyntaxNode, TextRange, TokenAtOffset,
 };
 
 use crate::{display::TryToNav, FilePosition, FileRange, NavigationTarget, RangeInfo};
@@ -89,6 +89,10 @@ pub(crate) fn find_all_refs(
     let _p = profile::span("find_all_refs");
     let syntax = sema.parse(position.file_id).syntax().clone();
 
+    if let Some(res) = try_find_self_references(&syntax, position) {
+        return Some(res);
+    }
+
     let (opt_name, search_kind) = if let Some(name) =
         get_struct_def_name_for_struct_literal_search(&sema, &syntax, position)
     {
@@ -194,6 +198,77 @@ fn get_struct_def_name_for_struct_literal_search(
     None
 }
 
+fn try_find_self_references(
+    syntax: &SyntaxNode,
+    position: FilePosition,
+) -> Option<RangeInfo<ReferenceSearchResult>> {
+    let self_token =
+        syntax.token_at_offset(position.offset).find(|t| t.kind() == SyntaxKind::SELF_KW)?;
+    let parent = self_token.parent();
+    match_ast! {
+        match parent {
+            ast::SelfParam(it) => (),
+            ast::PathSegment(segment) => {
+                segment.self_token()?;
+                let path = segment.parent_path();
+                if path.qualifier().is_some() && !ast::PathExpr::can_cast(path.syntax().parent()?.kind()) {
+                    return None;
+                }
+            },
+            _ => return None,
+        }
+    };
+    let function = parent.ancestors().find_map(ast::Fn::cast)?;
+    let self_param = function.param_list()?.self_param()?;
+    let param_self_token = self_param.self_token()?;
+
+    let declaration = Declaration {
+        nav: NavigationTarget {
+            file_id: position.file_id,
+            full_range: self_param.syntax().text_range(),
+            focus_range: Some(param_self_token.text_range()),
+            name: param_self_token.text().clone(),
+            kind: param_self_token.kind(),
+            container_name: None,
+            description: None,
+            docs: None,
+        },
+        kind: ReferenceKind::SelfKw,
+        access: Some(if self_param.mut_token().is_some() {
+            ReferenceAccess::Write
+        } else {
+            ReferenceAccess::Read
+        }),
+    };
+    let references = function
+        .body()
+        .map(|body| {
+            body.syntax()
+                .descendants()
+                .filter_map(ast::PathExpr::cast)
+                .filter_map(|expr| {
+                    let path = expr.path()?;
+                    if path.qualifier().is_none() {
+                        path.segment()?.self_token()
+                    } else {
+                        None
+                    }
+                })
+                .map(|token| Reference {
+                    file_range: FileRange { file_id: position.file_id, range: token.text_range() },
+                    kind: ReferenceKind::SelfKw,
+                    access: declaration.access, // FIXME: properly check access kind here instead of copying it from the declaration
+                })
+                .collect()
+        })
+        .unwrap_or_default();
+
+    Some(RangeInfo::new(
+        param_self_token.text_range(),
+        ReferenceSearchResult { declaration, references },
+    ))
+}
+
 #[cfg(test)]
 mod tests {
     use expect_test::{expect, Expect};
@@ -762,6 +837,32 @@ fn f() -> m::En {
         );
     }
 
+    #[test]
+    fn test_find_self_refs() {
+        check(
+            r#"
+struct Foo { bar: i32 }
+
+impl Foo {
+    fn foo(self) {
+        let x = self<|>.bar;
+        if true {
+            let _ = match () {
+                () => self,
+            };
+        }
+    }
+}
+"#,
+            expect![[r#"
+                self SELF_KW FileId(0) 47..51 47..51 SelfKw Read
+
+                FileId(0) 71..75 SelfKw Read
+                FileId(0) 152..156 SelfKw Read
+            "#]],
+        );
+    }
+
     fn check(ra_fixture: &str, expect: Expect) {
         check_with_scope(ra_fixture, None, expect)
     }
diff --git a/crates/ide/src/references/rename.rs b/crates/ide/src/references/rename.rs
index 91c64bd4a..64fe8bd65 100644
--- a/crates/ide/src/references/rename.rs
+++ b/crates/ide/src/references/rename.rs
@@ -221,24 +221,47 @@ fn rename_to_self(
     let source_file = sema.parse(position.file_id);
     let syn = source_file.syntax();
 
-    let fn_def = find_node_at_offset::<ast::Fn>(syn, position.offset)
+    let (fn_def, fn_ast) = find_node_at_offset::<ast::Fn>(syn, position.offset)
+        .and_then(|fn_ast| sema.to_def(&fn_ast).zip(Some(fn_ast)))
         .ok_or_else(|| RenameError("No surrounding method declaration found".to_string()))?;
-    let params =
-        fn_def.param_list().ok_or_else(|| RenameError("Method has no parameters".to_string()))?;
-    if params.self_param().is_some() {
+    let param_range = fn_ast
+        .param_list()
+        .and_then(|p| p.params().next())
+        .ok_or_else(|| RenameError("Method has no parameters".to_string()))?
+        .syntax()
+        .text_range();
+    if !param_range.contains(position.offset) {
+        return Err(RenameError("Only the first parameter can be self".to_string()));
+    }
+
+    let impl_block = find_node_at_offset::<ast::Impl>(syn, position.offset)
+        .and_then(|def| sema.to_def(&def))
+        .ok_or_else(|| RenameError("No impl block found for function".to_string()))?;
+    if fn_def.self_param(sema.db).is_some() {
         return Err(RenameError("Method already has a self parameter".to_string()));
     }
+
+    let params = fn_def.assoc_fn_params(sema.db);
     let first_param =
-        params.params().next().ok_or_else(|| RenameError("Method has no parameters".into()))?;
-    let mutable = match first_param.ty() {
-        Some(ast::Type::RefType(rt)) => rt.mut_token().is_some(),
-        _ => return Err(RenameError("Not renaming other types".to_string())),
+        params.first().ok_or_else(|| RenameError("Method has no parameters".into()))?;
+    let first_param_ty = first_param.ty();
+    let impl_ty = impl_block.target_ty(sema.db);
+    let (ty, self_param) = if impl_ty.remove_ref().is_some() {
+        // if the impl is a ref to the type we can just match the `&T` with self directly
+        (first_param_ty.clone(), "self")
+    } else {
+        first_param_ty.remove_ref().map_or((first_param_ty.clone(), "self"), |ty| {
+            (ty, if first_param_ty.is_mutable_reference() { "&mut self" } else { "&self" })
+        })
     };
 
+    if ty != impl_ty {
+        return Err(RenameError("Parameter type differs from impl block type".to_string()));
+    }
+
     let RangeInfo { range, info: refs } = find_all_refs(sema, position, None)
         .ok_or_else(|| RenameError("No reference found at position".to_string()))?;
 
-    let param_range = first_param.syntax().text_range();
     let (param_ref, usages): (Vec<Reference>, Vec<Reference>) = refs
         .into_iter()
         .partition(|reference| param_range.intersect(reference.file_range.range).is_some());
@@ -254,10 +277,7 @@ fn rename_to_self(
 
     edits.push(SourceFileEdit {
         file_id: position.file_id,
-        edit: TextEdit::replace(
-            param_range,
-            String::from(if mutable { "&mut self" } else { "&self" }),
-        ),
+        edit: TextEdit::replace(param_range, String::from(self_param)),
     });
 
     Ok(RangeInfo::new(range, SourceChange::from(edits)))
@@ -280,7 +300,11 @@ fn text_edit_from_self_param(
 
     let mut replacement_text = String::from(new_name);
     replacement_text.push_str(": ");
-    replacement_text.push_str(self_param.mut_token().map_or("&", |_| "&mut "));
+    match (self_param.amp_token(), self_param.mut_token()) {
+        (None, None) => (),
+        (Some(_), None) => replacement_text.push('&'),
+        (_, Some(_)) => replacement_text.push_str("&mut "),
+    };
     replacement_text.push_str(type_name.as_str());
 
     Some(TextEdit::replace(self_param.syntax().text_range(), replacement_text))
@@ -1082,6 +1106,95 @@ impl Foo {
 }
 "#,
         );
+        check(
+            "self",
+            r#"
+struct Foo { i: i32 }
+
+impl Foo {
+    fn f(foo<|>: Foo) -> i32 {
+        foo.i
+    }
+}
+"#,
+            r#"
+struct Foo { i: i32 }
+
+impl Foo {
+    fn f(self) -> i32 {
+        self.i
+    }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn test_parameter_to_self_error_no_impl() {
+        check(
+            "self",
+            r#"
+struct Foo { i: i32 }
+
+fn f(foo<|>: &mut Foo) -> i32 {
+    foo.i
+}
+"#,
+            "error: No impl block found for function",
+        );
+        check(
+            "self",
+            r#"
+struct Foo { i: i32 }
+struct Bar;
+
+impl Bar {
+    fn f(foo<|>: &mut Foo) -> i32 {
+        foo.i
+    }
+}
+"#,
+            "error: Parameter type differs from impl block type",
+        );
+    }
+
+    #[test]
+    fn test_parameter_to_self_error_not_first() {
+        check(
+            "self",
+            r#"
+struct Foo { i: i32 }
+impl Foo {
+    fn f(x: (), foo<|>: &mut Foo) -> i32 {
+        foo.i
+    }
+}
+"#,
+            "error: Only the first parameter can be self",
+        );
+    }
+
+    #[test]
+    fn test_parameter_to_self_impl_ref() {
+        check(
+            "self",
+            r#"
+struct Foo { i: i32 }
+impl &Foo {
+    fn f(foo<|>: &Foo) -> i32 {
+        foo.i
+    }
+}
+"#,
+            r#"
+struct Foo { i: i32 }
+impl &Foo {
+    fn f(self) -> i32 {
+        self.i
+    }
+}
+"#,
+        );
     }
 
     #[test]
@@ -1110,6 +1223,31 @@ impl Foo {
     }
 
     #[test]
+    fn test_owned_self_to_parameter() {
+        check(
+            "foo",
+            r#"
+struct Foo { i: i32 }
+
+impl Foo {
+    fn f(<|>self) -> i32 {
+        self.i
+    }
+}
+"#,
+            r#"
+struct Foo { i: i32 }
+
+impl Foo {
+    fn f(foo: Foo) -> i32 {
+        foo.i
+    }
+}
+"#,
+        );
+    }
+
+    #[test]
     fn test_self_in_path_to_parameter() {
         check(
             "foo",
diff --git a/crates/ide/src/syntax_highlighting.rs b/crates/ide/src/syntax_highlighting.rs
index 1ed77b40b..5150a970c 100644
--- a/crates/ide/src/syntax_highlighting.rs
+++ b/crates/ide/src/syntax_highlighting.rs
@@ -76,6 +76,7 @@ pub(crate) fn highlight(
     let mut current_macro_call: Option<ast::MacroCall> = None;
     let mut format_string_highlighter = FormatStringHighlighter::default();
     let mut macro_rules_highlighter = MacroRulesHighlighter::default();
+    let mut inside_attribute = false;
 
     // Walk all nodes, keeping track of whether we are inside a macro or not.
     // If in macro, expand it first and highlight the expanded code.
@@ -132,9 +133,12 @@ pub(crate) fn highlight(
             _ => (),
         }
 
-        // Check for Rust code in documentation
         match &event {
+            // Check for Rust code in documentation
             WalkEvent::Leave(NodeOrToken::Node(node)) => {
+                if ast::Attr::can_cast(node.kind()) {
+                    inside_attribute = false
+                }
                 if let Some((doctest, range_mapping, new_comments)) =
                     injection::extract_doc_comments(node)
                 {
@@ -146,6 +150,9 @@ pub(crate) fn highlight(
                     );
                 }
             }
+            WalkEvent::Enter(NodeOrToken::Node(node)) if ast::Attr::can_cast(node.kind()) => {
+                inside_attribute = true
+            }
             _ => (),
         }
 
@@ -188,12 +195,16 @@ pub(crate) fn highlight(
             }
         }
 
-        if let Some((highlight, binding_hash)) = highlight_element(
+        if let Some((mut highlight, binding_hash)) = highlight_element(
             &sema,
             &mut bindings_shadow_count,
             syntactic_name_ref_highlighting,
             element_to_highlight.clone(),
         ) {
+            if inside_attribute {
+                highlight = highlight | HighlightModifier::Attribute;
+            }
+
             if macro_rules_highlighter.highlight(element_to_highlight.clone()).is_none() {
                 stack.add(HighlightedRange { range, highlight, binding_hash });
             }
@@ -474,7 +485,9 @@ fn highlight_element(
 
         // Highlight references like the definitions they resolve to
         NAME_REF if element.ancestors().any(|it| it.kind() == ATTR) => {
-            Highlight::from(HighlightTag::Function) | HighlightModifier::Attribute
+            // even though we track whether we are in an attribute or not we still need this special case
+            // as otherwise we would emit unresolved references for name refs inside attributes
+            Highlight::from(HighlightTag::Function)
         }
         NAME_REF => {
             let name_ref = element.into_node().and_then(ast::NameRef::cast).unwrap();
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html b/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
index 6be88f856..d79fa6dca 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
@@ -50,7 +50,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
     <span class="comment documentation">/// # Examples</span>
     <span class="comment documentation">///</span>
     <span class="comment documentation">/// ```</span>
-    <span class="comment documentation">/// #</span><span class="generic injected"> </span><span class="attribute injected">#</span><span class="attribute injected">!</span><span class="attribute injected">[</span><span class="function attribute injected">allow</span><span class="punctuation injected">(</span><span class="attribute injected">unused_mut</span><span class="punctuation injected">)</span><span class="attribute injected">]</span>
+    <span class="comment documentation">/// #</span><span class="generic injected"> </span><span class="attribute attribute injected">#</span><span class="attribute attribute injected">!</span><span class="attribute attribute injected">[</span><span class="function attribute injected">allow</span><span class="punctuation attribute injected">(</span><span class="attribute attribute injected">unused_mut</span><span class="punctuation attribute injected">)</span><span class="attribute attribute injected">]</span>
     <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="generic injected"> </span><span class="keyword injected">mut</span><span class="generic injected"> </span><span class="variable declaration injected mutable">foo</span><span class="punctuation injected">:</span><span class="generic injected"> </span><span class="struct injected">Foo</span><span class="generic injected"> </span><span class="operator injected">=</span><span class="generic injected"> </span><span class="struct injected">Foo</span><span class="operator injected">::</span><span class="function injected">new</span><span class="punctuation injected">(</span><span class="punctuation injected">)</span><span class="punctuation injected">;</span><span class="punctuation injected">
 </span>    <span class="comment documentation">/// ```</span>
     <span class="keyword">pub</span> <span class="keyword">const</span> <span class="keyword">fn</span> <span class="function declaration static">new</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="struct">Foo</span> <span class="punctuation">{</span>
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html b/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
index 4b6d6adc9..1d05b7713 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
@@ -54,7 +54,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 
 <span class="keyword">static</span> <span class="keyword">mut</span> <span class="static declaration mutable unsafe">global_mut</span><span class="punctuation">:</span> <span class="struct">TypeForStaticMut</span> <span class="operator">=</span> <span class="struct">TypeForStaticMut</span> <span class="punctuation">{</span> <span class="field">a</span><span class="punctuation">:</span> <span class="numeric_literal">0</span> <span class="punctuation">}</span><span class="punctuation">;</span>
 
-<span class="attribute">#</span><span class="attribute">[</span><span class="function attribute">repr</span><span class="punctuation">(</span><span class="attribute">packed</span><span class="punctuation">)</span><span class="attribute">]</span>
+<span class="attribute attribute">#</span><span class="attribute attribute">[</span><span class="function attribute">repr</span><span class="punctuation attribute">(</span><span class="attribute attribute">packed</span><span class="punctuation attribute">)</span><span class="attribute attribute">]</span>
 <span class="keyword">struct</span> <span class="struct declaration">Packed</span> <span class="punctuation">{</span>
     <span class="field declaration">a</span><span class="punctuation">:</span> <span class="builtin_type">u16</span><span class="punctuation">,</span>
 <span class="punctuation">}</span>
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlighting.html b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
index 6a10a9dcd..15fbf2ce3 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlighting.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
@@ -40,18 +40,18 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 
 <span class="comment">// Needed for function consuming vs normal</span>
 <span class="keyword">pub</span> <span class="keyword">mod</span> <span class="module declaration">marker</span> <span class="punctuation">{</span>
-    <span class="attribute">#</span><span class="attribute">[</span><span class="function attribute">lang</span><span class="attribute"> </span><span class="operator">=</span><span class="attribute"> </span><span class="string_literal">"copy"</span><span class="attribute">]</span>
+    <span class="attribute attribute">#</span><span class="attribute attribute">[</span><span class="function attribute">lang</span><span class="attribute attribute"> </span><span class="operator attribute">=</span><span class="attribute attribute"> </span><span class="string_literal attribute">"copy"</span><span class="attribute attribute">]</span>
     <span class="keyword">pub</span> <span class="keyword">trait</span> <span class="trait declaration">Copy</span> <span class="punctuation">{</span><span class="punctuation">}</span>
 <span class="punctuation">}</span>
 
 <span class="keyword">pub</span> <span class="keyword">mod</span> <span class="module declaration">ops</span> <span class="punctuation">{</span>
-    <span class="attribute">#</span><span class="attribute">[</span><span class="function attribute">lang</span><span class="attribute"> </span><span class="operator">=</span><span class="attribute"> </span><span class="string_literal">"fn_once"</span><span class="attribute">]</span>
+    <span class="attribute attribute">#</span><span class="attribute attribute">[</span><span class="function attribute">lang</span><span class="attribute attribute"> </span><span class="operator attribute">=</span><span class="attribute attribute"> </span><span class="string_literal attribute">"fn_once"</span><span class="attribute attribute">]</span>
     <span class="keyword">pub</span> <span class="keyword">trait</span> <span class="trait declaration">FnOnce</span><span class="punctuation">&lt;</span><span class="type_param declaration">Args</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span><span class="punctuation">}</span>
 
-    <span class="attribute">#</span><span class="attribute">[</span><span class="function attribute">lang</span><span class="attribute"> </span><span class="operator">=</span><span class="attribute"> </span><span class="string_literal">"fn_mut"</span><span class="attribute">]</span>
+    <span class="attribute attribute">#</span><span class="attribute attribute">[</span><span class="function attribute">lang</span><span class="attribute attribute"> </span><span class="operator attribute">=</span><span class="attribute attribute"> </span><span class="string_literal attribute">"fn_mut"</span><span class="attribute attribute">]</span>
     <span class="keyword">pub</span> <span class="keyword">trait</span> <span class="trait declaration">FnMut</span><span class="punctuation">&lt;</span><span class="type_param declaration">Args</span><span class="punctuation">&gt;</span><span class="punctuation">:</span> <span class="trait">FnOnce</span><span class="punctuation">&lt;</span><span class="type_param">Args</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span><span class="punctuation">}</span>
 
-    <span class="attribute">#</span><span class="attribute">[</span><span class="function attribute">lang</span><span class="attribute"> </span><span class="operator">=</span><span class="attribute"> </span><span class="string_literal">"fn"</span><span class="attribute">]</span>
+    <span class="attribute attribute">#</span><span class="attribute attribute">[</span><span class="function attribute">lang</span><span class="attribute attribute"> </span><span class="operator attribute">=</span><span class="attribute attribute"> </span><span class="string_literal attribute">"fn"</span><span class="attribute attribute">]</span>
     <span class="keyword">pub</span> <span class="keyword">trait</span> <span class="trait declaration">Fn</span><span class="punctuation">&lt;</span><span class="type_param declaration">Args</span><span class="punctuation">&gt;</span><span class="punctuation">:</span> <span class="trait">FnMut</span><span class="punctuation">&lt;</span><span class="type_param">Args</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span><span class="punctuation">}</span>
 <span class="punctuation">}</span>
 
@@ -85,7 +85,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
     <span class="punctuation">}</span>
 <span class="punctuation">}</span>
 
-<span class="attribute">#</span><span class="attribute">[</span><span class="function attribute">derive</span><span class="punctuation">(</span><span class="attribute">Copy</span><span class="punctuation">)</span><span class="attribute">]</span>
+<span class="attribute attribute">#</span><span class="attribute attribute">[</span><span class="function attribute">derive</span><span class="punctuation attribute">(</span><span class="attribute attribute">Copy</span><span class="punctuation attribute">)</span><span class="attribute attribute">]</span>
 <span class="keyword">struct</span> <span class="struct declaration">FooCopy</span> <span class="punctuation">{</span>
     <span class="field declaration">x</span><span class="punctuation">:</span> <span class="builtin_type">u32</span><span class="punctuation">,</span>
 <span class="punctuation">}</span>
diff --git a/crates/ide_db/src/helpers/insert_use.rs b/crates/ide_db/src/helpers/insert_use.rs
index 67e800fad..08d246c16 100644
--- a/crates/ide_db/src/helpers/insert_use.rs
+++ b/crates/ide_db/src/helpers/insert_use.rs
@@ -384,7 +384,7 @@ fn path_cmp_for_sort(a: Option<ast::Path>, b: Option<ast::Path>) -> Ordering {
 
 /// Path comparison func for binary searching for merging.
 fn path_cmp_bin_search(lhs: Option<ast::Path>, rhs: Option<ast::Path>) -> Ordering {
-    match (lhs.and_then(|path| path.segment()), rhs.and_then(|path| path.segment())) {
+    match (lhs.as_ref().and_then(first_segment), rhs.as_ref().and_then(first_segment)) {
         (None, None) => Ordering::Equal,
         (None, Some(_)) => Ordering::Less,
         (Some(_), None) => Ordering::Greater,
@@ -1082,6 +1082,15 @@ use std::io;",
     }
 
     #[test]
+    fn merge_nested_considers_first_segments() {
+        check_full(
+            "hir_ty::display::write_bounds_like_dyn_trait",
+            r"use hir_ty::{autoderef, display::{HirDisplayError, HirFormatter}, method_resolution};",
+            r"use hir_ty::{autoderef, display::{HirDisplayError, HirFormatter, write_bounds_like_dyn_trait}, method_resolution};",
+        );
+    }
+
+    #[test]
     fn skip_merge_last_too_long() {
         check_last(
             "foo::bar",
diff --git a/crates/ide_db/src/search.rs b/crates/ide_db/src/search.rs
index a3e765d05..607185ca9 100644
--- a/crates/ide_db/src/search.rs
+++ b/crates/ide_db/src/search.rs
@@ -31,6 +31,7 @@ pub enum ReferenceKind {
     FieldShorthandForLocal,
     StructLiteral,
     RecordFieldExprOrPat,
+    SelfKw,
     Other,
 }
 
diff --git a/crates/rust-analyzer/Cargo.toml b/crates/rust-analyzer/Cargo.toml
index 08559b53a..0a055b039 100644
--- a/crates/rust-analyzer/Cargo.toml
+++ b/crates/rust-analyzer/Cargo.toml
@@ -21,7 +21,7 @@ env_logger = { version = "0.8.1", default-features = false }
 itertools = "0.9.0"
 jod-thread = "0.1.0"
 log = "0.4.8"
-lsp-types = { version = "0.84.0", features = ["proposed"] }
+lsp-types = { version = "0.85.0", features = ["proposed"] }
 parking_lot = "0.11.0"
 pico-args = "0.3.1"
 oorandom = "11.1.2"
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 30299a465..59269a74b 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -480,7 +480,7 @@ macro_rules! config_data {
 
 config_data! {
     struct ConfigData {
-        assist_importMergeBehaviour: MergeBehaviourDef = MergeBehaviourDef::None,
+        assist_importMergeBehaviour: MergeBehaviourDef = MergeBehaviourDef::Full,
         assist_importPrefix: ImportPrefixDef           = ImportPrefixDef::Plain,
 
         callInfo_full: bool = true,
diff --git a/crates/rust-analyzer/src/semantic_tokens.rs b/crates/rust-analyzer/src/semantic_tokens.rs
index e7991fd28..1daad1c98 100644
--- a/crates/rust-analyzer/src/semantic_tokens.rs
+++ b/crates/rust-analyzer/src/semantic_tokens.rs
@@ -27,7 +27,7 @@ macro_rules! define_semantic_token_types {
             SemanticTokenType::ENUM_MEMBER,
             SemanticTokenType::TYPE_PARAMETER,
             SemanticTokenType::FUNCTION,
-            SemanticTokenType::MEMBER,
+            SemanticTokenType::METHOD,
             SemanticTokenType::PROPERTY,
             SemanticTokenType::MACRO,
             SemanticTokenType::VARIABLE,
diff --git a/crates/syntax/Cargo.toml b/crates/syntax/Cargo.toml
index ce62babc3..c6a6f11e1 100644
--- a/crates/syntax/Cargo.toml
+++ b/crates/syntax/Cargo.toml
@@ -13,7 +13,7 @@ doctest = false
 [dependencies]
 itertools = "0.9.0"
 rowan = "0.10.0"
-rustc_lexer = { version = "688.0.0", package = "rustc-ap-rustc_lexer" }
+rustc_lexer = { version = "691.0.0", package = "rustc-ap-rustc_lexer" }
 rustc-hash = "1.1.0"
 arrayvec = "0.5.1"
 once_cell = "1.3.1"