15 files changed, 350 insertions, 179 deletions

diff --git a/crates/assists/src/handlers/generate_from_impl_for_enum.rs b/crates/assists/src/handlers/generate_from_impl_for_enum.rs
index f6febd3aa..d9388a737 100644
--- a/crates/assists/src/handlers/generate_from_impl_for_enum.rs
+++ b/crates/assists/src/handlers/generate_from_impl_for_enum.rs
@@ -1,15 +1,9 @@
-use ast::GenericParamsOwner;
 use ide_db::helpers::FamousDefs;
 use ide_db::RootDatabase;
-use itertools::Itertools;
-use stdx::format_to;
-use syntax::{
-    ast::{self, AstNode, NameOwner},
-    SmolStr,
-};
+use syntax::ast::{self, AstNode, NameOwner};
 use test_utils::mark;
 
-use crate::{AssistContext, AssistId, AssistKind, Assists};
+use crate::{utils::generate_trait_impl_text, AssistContext, AssistId, AssistKind, Assists};
 
 // Assist: generate_from_impl_for_enum
 //
@@ -31,8 +25,7 @@ use crate::{AssistContext, AssistId, AssistKind, Assists};
 pub(crate) fn generate_from_impl_for_enum(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
     let variant = ctx.find_node_at_offset::<ast::Variant>()?;
     let variant_name = variant.name()?;
-    let enum_name = variant.parent_enum().name()?;
-    let enum_type_params = variant.parent_enum().generic_param_list();
+    let enum_ = ast::Adt::Enum(variant.parent_enum());
     let (field_name, field_type) = match variant.kind() {
         ast::StructKind::Tuple(field_list) => {
             if field_list.fields().count() != 1 {
@@ -62,49 +55,27 @@ pub(crate) fn generate_from_impl_for_enum(acc: &mut Assists, ctx: &AssistContext
         target,
         |edit| {
             let start_offset = variant.parent_enum().syntax().text_range().end();
-            let mut buf = String::from("\n\nimpl");
-            if let Some(type_params) = &enum_type_params {
-                format_to!(buf, "{}", type_params.syntax());
-            }
-            format_to!(buf, " From<{}> for {}", field_type.syntax(), enum_name);
-            if let Some(type_params) = enum_type_params {
-                let lifetime_params = type_params
-                    .lifetime_params()
-                    .filter_map(|it| it.lifetime())
-                    .map(|it| SmolStr::from(it.text()));
-                let type_params = type_params
-                    .type_params()
-                    .filter_map(|it| it.name())
-                    .map(|it| SmolStr::from(it.text()));
-
-                let generic_params = lifetime_params.chain(type_params).format(", ");
-                format_to!(buf, "<{}>", generic_params)
-            }
-            if let Some(name) = field_name {
-                format_to!(
-                    buf,
-                    r#" {{
-    fn from({0}: {1}) -> Self {{
+            let from_trait = format!("From<{}>", field_type.syntax());
+            let impl_code = if let Some(name) = field_name {
+                format!(
+                    r#"    fn from({0}: {1}) -> Self {{
         Self::{2} {{ {0} }}
-    }}
-}}"#,
+    }}"#,
                     name.text(),
                     field_type.syntax(),
                     variant_name,
-                );
+                )
             } else {
-                format_to!(
-                    buf,
-                    r#" {{
-    fn from(v: {}) -> Self {{
+                format!(
+                    r#"    fn from(v: {}) -> Self {{
         Self::{}(v)
-    }}
-}}"#,
+    }}"#,
                     field_type.syntax(),
                     variant_name,
-                );
-            }
-            edit.insert(start_offset, buf);
+                )
+            };
+            let from_impl = generate_trait_impl_text(&enum_, &from_trait, &impl_code);
+            edit.insert(start_offset, from_impl);
         },
     )
 }
diff --git a/crates/assists/src/handlers/generate_impl.rs b/crates/assists/src/handlers/generate_impl.rs
index 61d1bd25c..16a600e6f 100644
--- a/crates/assists/src/handlers/generate_impl.rs
+++ b/crates/assists/src/handlers/generate_impl.rs
@@ -1,11 +1,6 @@
-use itertools::Itertools;
-use stdx::format_to;
-use syntax::{
-    ast::{self, AstNode, AttrsOwner, GenericParamsOwner, NameOwner},
-    SmolStr,
-};
+use syntax::ast::{self, AstNode, NameOwner};
 
-use crate::{AssistContext, AssistId, AssistKind, Assists};
+use crate::{utils::generate_impl_text, AssistContext, AssistId, AssistKind, Assists};
 
 // Assist: generate_impl
 //
@@ -36,44 +31,15 @@ pub(crate) fn generate_impl(acc: &mut Assists, ctx: &AssistContext) -> Option<()
         format!("Generate impl for `{}`", name),
         target,
         |edit| {
-            let type_params = nominal.generic_param_list();
             let start_offset = nominal.syntax().text_range().end();
-            let mut buf = String::new();
-            buf.push_str("\n\n");
-            nominal
-                .attrs()
-                .filter(|attr| {
-                    attr.as_simple_call().map(|(name, _arg)| name == "cfg").unwrap_or(false)
-                })
-                .for_each(|attr| buf.push_str(format!("{}\n", attr.to_string()).as_str()));
-
-            buf.push_str("impl");
-            if let Some(type_params) = &type_params {
-                format_to!(buf, "{}", type_params.syntax());
-            }
-            buf.push_str(" ");
-            buf.push_str(name.text());
-            if let Some(type_params) = type_params {
-                let lifetime_params = type_params
-                    .lifetime_params()
-                    .filter_map(|it| it.lifetime())
-                    .map(|it| SmolStr::from(it.text()));
-                let type_params = type_params
-                    .type_params()
-                    .filter_map(|it| it.name())
-                    .map(|it| SmolStr::from(it.text()));
-
-                let generic_params = lifetime_params.chain(type_params).format(", ");
-                format_to!(buf, "<{}>", generic_params)
-            }
             match ctx.config.snippet_cap {
                 Some(cap) => {
-                    buf.push_str(" {\n    $0\n}");
-                    edit.insert_snippet(cap, start_offset, buf);
+                    let snippet = generate_impl_text(&nominal, "    $0");
+                    edit.insert_snippet(cap, start_offset, snippet);
                 }
                 None => {
-                    buf.push_str(" {\n}");
-                    edit.insert(start_offset, buf);
+                    let snippet = generate_impl_text(&nominal, "");
+                    edit.insert(start_offset, snippet);
                 }
             }
         },
@@ -132,6 +98,30 @@ mod tests {
                 $0
             }"#,
         );
+
+        check_assist(
+            generate_impl,
+            r#"
+            struct Defaulted<T = i32> {}$0"#,
+            r#"
+            struct Defaulted<T = i32> {}
+
+            impl<T> Defaulted<T> {
+                $0
+            }"#,
+        );
+
+        check_assist(
+            generate_impl,
+            r#"
+            struct Defaulted<'a, 'b: 'a, T: Debug + Clone + 'a + 'b = String> {}$0"#,
+            r#"
+            struct Defaulted<'a, 'b: 'a, T: Debug + Clone + 'a + 'b = String> {}
+
+            impl<'a, 'b: 'a, T: Debug + Clone + 'a + 'b> Defaulted<'a, 'b, T> {
+                $0
+            }"#,
+        );
     }
 
     #[test]
diff --git a/crates/assists/src/handlers/replace_derive_with_manual_impl.rs b/crates/assists/src/handlers/replace_derive_with_manual_impl.rs
index 6aa9d2f2c..c69bc5cac 100644
--- a/crates/assists/src/handlers/replace_derive_with_manual_impl.rs
+++ b/crates/assists/src/handlers/replace_derive_with_manual_impl.rs
@@ -2,8 +2,7 @@ use ide_db::helpers::mod_path_to_ast;
 use ide_db::imports_locator;
 use itertools::Itertools;
 use syntax::{
-    ast::{self, make, AstNode},
-    Direction,
+    ast::{self, make, AstNode, NameOwner},
     SyntaxKind::{IDENT, WHITESPACE},
     TextSize,
 };
@@ -11,7 +10,8 @@ use syntax::{
 use crate::{
     assist_context::{AssistBuilder, AssistContext, Assists},
     utils::{
-        add_trait_assoc_items_to_impl, filter_assoc_items, render_snippet, Cursor, DefaultMethods,
+        add_trait_assoc_items_to_impl, filter_assoc_items, generate_trait_impl_text,
+        render_snippet, Cursor, DefaultMethods,
     },
     AssistId, AssistKind,
 };
@@ -57,8 +57,9 @@ pub(crate) fn replace_derive_with_manual_impl(
     let trait_token = ctx.token_at_offset().find(|t| t.kind() == IDENT && t.text() != "derive")?;
     let trait_path = make::path_unqualified(make::path_segment(make::name_ref(trait_token.text())));
 
-    let annotated_name = attr.syntax().siblings(Direction::Next).find_map(ast::Name::cast)?;
-    let insert_pos = annotated_name.syntax().parent()?.text_range().end();
+    let adt = attr.syntax().parent().and_then(ast::Adt::cast)?;
+    let annotated_name = adt.name()?;
+    let insert_pos = adt.syntax().text_range().end();
 
     let current_module = ctx.sema.scope(annotated_name.syntax()).module()?;
     let current_crate = current_module.krate();
@@ -82,10 +83,10 @@ pub(crate) fn replace_derive_with_manual_impl(
 
     let mut no_traits_found = true;
     for (trait_path, trait_) in found_traits.inspect(|_| no_traits_found = false) {
-        add_assist(acc, ctx, &attr, &trait_path, Some(trait_), &annotated_name, insert_pos)?;
+        add_assist(acc, ctx, &attr, &trait_path, Some(trait_), &adt, &annotated_name, insert_pos)?;
     }
     if no_traits_found {
-        add_assist(acc, ctx, &attr, &trait_path, None, &annotated_name, insert_pos)?;
+        add_assist(acc, ctx, &attr, &trait_path, None, &adt, &annotated_name, insert_pos)?;
     }
     Some(())
 }
@@ -96,6 +97,7 @@ fn add_assist(
     attr: &ast::Attr,
     trait_path: &ast::Path,
     trait_: Option<hir::Trait>,
+    adt: &ast::Adt,
     annotated_name: &ast::Name,
     insert_pos: TextSize,
 ) -> Option<()> {
@@ -112,15 +114,15 @@ fn add_assist(
             let impl_def_with_items =
                 impl_def_from_trait(&ctx.sema, annotated_name, trait_, trait_path);
             update_attribute(builder, &input, &trait_name, &attr);
+            let trait_path = format!("{}", trait_path);
             match (ctx.config.snippet_cap, impl_def_with_items) {
-                (None, _) => builder.insert(
-                    insert_pos,
-                    format!("\n\nimpl {} for {} {{\n\n}}", trait_path, annotated_name),
-                ),
+                (None, _) => {
+                    builder.insert(insert_pos, generate_trait_impl_text(adt, &trait_path, ""))
+                }
                 (Some(cap), None) => builder.insert_snippet(
                     cap,
                     insert_pos,
-                    format!("\n\nimpl {} for {} {{\n    $0\n}}", trait_path, annotated_name),
+                    generate_trait_impl_text(adt, &trait_path, "    $0"),
                 ),
                 (Some(cap), Some((impl_def, first_assoc_item))) => {
                     let mut cursor = Cursor::Before(first_assoc_item.syntax());
diff --git a/crates/assists/src/utils.rs b/crates/assists/src/utils.rs
index 5dd32aef1..8418e6e12 100644
--- a/crates/assists/src/utils.rs
+++ b/crates/assists/src/utils.rs
@@ -2,6 +2,7 @@
 
 use std::ops;
 
+use ast::TypeBoundsOwner;
 use hir::{Adt, HasSource};
 use ide_db::{helpers::SnippetCap, RootDatabase};
 use itertools::Itertools;
@@ -367,21 +368,56 @@ pub(crate) fn find_impl_block_end(impl_def: ast::Impl, buf: &mut String) -> Opti
 // Generates the surrounding `impl Type { <code> }` including type and lifetime
 // parameters
 pub(crate) fn generate_impl_text(adt: &ast::Adt, code: &str) -> String {
-    let type_params = adt.generic_param_list();
+    generate_impl_text_inner(adt, None, code)
+}
+
+// Generates the surrounding `impl <trait> for Type { <code> }` including type
+// and lifetime parameters
+pub(crate) fn generate_trait_impl_text(adt: &ast::Adt, trait_text: &str, code: &str) -> String {
+    generate_impl_text_inner(adt, Some(trait_text), code)
+}
+
+fn generate_impl_text_inner(adt: &ast::Adt, trait_text: Option<&str>, code: &str) -> String {
+    let generic_params = adt.generic_param_list();
     let mut buf = String::with_capacity(code.len());
-    buf.push_str("\n\nimpl");
-    if let Some(type_params) = &type_params {
-        format_to!(buf, "{}", type_params.syntax());
+    buf.push_str("\n\n");
+    adt.attrs()
+        .filter(|attr| attr.as_simple_call().map(|(name, _arg)| name == "cfg").unwrap_or(false))
+        .for_each(|attr| buf.push_str(format!("{}\n", attr.to_string()).as_str()));
+    buf.push_str("impl");
+    if let Some(generic_params) = &generic_params {
+        let lifetimes = generic_params.lifetime_params().map(|lt| format!("{}", lt.syntax()));
+        let type_params = generic_params.type_params().map(|type_param| {
+            let mut buf = String::new();
+            if let Some(it) = type_param.name() {
+                format_to!(buf, "{}", it.syntax());
+            }
+            if let Some(it) = type_param.colon_token() {
+                format_to!(buf, "{} ", it);
+            }
+            if let Some(it) = type_param.type_bound_list() {
+                format_to!(buf, "{}", it.syntax());
+            }
+            buf
+        });
+        let generics = lifetimes.chain(type_params).format(", ");
+        format_to!(buf, "<{}>", generics);
     }
     buf.push(' ');
+    if let Some(trait_text) = trait_text {
+        buf.push_str(trait_text);
+        buf.push_str(" for ");
+    }
     buf.push_str(adt.name().unwrap().text());
-    if let Some(type_params) = type_params {
-        let lifetime_params = type_params
+    if let Some(generic_params) = generic_params {
+        let lifetime_params = generic_params
             .lifetime_params()
             .filter_map(|it| it.lifetime())
             .map(|it| SmolStr::from(it.text()));
-        let type_params =
-            type_params.type_params().filter_map(|it| it.name()).map(|it| SmolStr::from(it.text()));
+        let type_params = generic_params
+            .type_params()
+            .filter_map(|it| it.name())
+            .map(|it| SmolStr::from(it.text()));
         format_to!(buf, "<{}>", lifetime_params.chain(type_params).format(", "))
     }
 
diff --git a/crates/ide/src/references.rs b/crates/ide/src/references.rs
index c7cefb3b6..17086f7d4 100644
--- a/crates/ide/src/references.rs
+++ b/crates/ide/src/references.rs
@@ -1127,4 +1127,39 @@ impl Foo {
             "#]],
         );
     }
+
+    #[test]
+    fn test_attr_differs_from_fn_with_same_name() {
+        check(
+            r#"
+#[test]
+fn test$0() {
+    test();
+}
+"#,
+            expect![[r#"
+                test Function FileId(0) 0..33 11..15
+
+                FileId(0) 24..28
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_attr_matches_proc_macro_fn() {
+        check(
+            r#"
+#[proc_macro_attribute]
+fn my_proc_macro() {}
+
+#[my_proc_macro$0]
+fn test() {}
+"#,
+            expect![[r#"
+                my_proc_macro Function FileId(0) 0..45 27..40
+
+                FileId(0) 49..62
+            "#]],
+        );
+    }
 }
diff --git a/crates/ide/src/references/rename.rs b/crates/ide/src/references/rename.rs
index b04214291..08f16b54d 100644
--- a/crates/ide/src/references/rename.rs
+++ b/crates/ide/src/references/rename.rs
@@ -75,8 +75,7 @@ pub(crate) fn rename_with_semantics(
     let source_file = sema.parse(position.file_id);
     let syntax = source_file.syntax();
 
-    let def = find_definition(sema, syntax, position)
-        .ok_or_else(|| format_err!("No references found at position"))?;
+    let def = find_definition(sema, syntax, position)?;
     match def {
         Definition::ModuleDef(ModuleDef::Module(module)) => rename_mod(&sema, module, new_name),
         def => rename_reference(sema, def, new_name),
@@ -149,18 +148,30 @@ fn find_definition(
     sema: &Semantics<RootDatabase>,
     syntax: &SyntaxNode,
     position: FilePosition,
-) -> Option<Definition> {
-    let def = match find_name_like(sema, syntax, position)? {
-        NameLike::Name(name) => NameClass::classify(sema, &name)?.referenced_or_defined(sema.db),
-        NameLike::NameRef(name_ref) => NameRefClass::classify(sema, &name_ref)?.referenced(sema.db),
+) -> RenameResult<Definition> {
+    match find_name_like(sema, syntax, position)
+        .ok_or_else(|| format_err!("No references found at position"))?
+    {
+        // renaming aliases would rename the item being aliased as the HIR doesn't track aliases yet
+        NameLike::Name(name)
+            if name.syntax().parent().map_or(false, |it| ast::Rename::can_cast(it.kind())) =>
+        {
+            bail!("Renaming aliases is currently unsupported")
+        }
+        NameLike::Name(name) => {
+            NameClass::classify(sema, &name).map(|class| class.referenced_or_defined(sema.db))
+        }
+        NameLike::NameRef(name_ref) => {
+            NameRefClass::classify(sema, &name_ref).map(|class| class.referenced(sema.db))
+        }
         NameLike::Lifetime(lifetime) => NameRefClass::classify_lifetime(sema, &lifetime)
             .map(|class| NameRefClass::referenced(class, sema.db))
             .or_else(|| {
                 NameClass::classify_lifetime(sema, &lifetime)
                     .map(|it| it.referenced_or_defined(sema.db))
-            })?,
-    };
-    Some(def)
+            }),
+    }
+    .ok_or_else(|| format_err!("No references found at position"))
 }
 
 fn source_edit_from_references(
@@ -173,21 +184,40 @@ fn source_edit_from_references(
     let mut edit = TextEdit::builder();
     for reference in references {
         let (range, replacement) = match &reference.name {
-            NameLike::Name(_) => (None, format!("{}", new_name)),
-            NameLike::NameRef(name_ref) => source_edit_from_name_ref(name_ref, new_name, def),
-            NameLike::Lifetime(_) => (None, format!("{}", new_name)),
-        };
-        // FIXME: Some(range) will be incorrect when we are inside macros
-        edit.replace(range.unwrap_or(reference.range), replacement);
+            // if the ranges differ then the node is inside a macro call, we can't really attempt
+            // to make special rewrites like shorthand syntax and such, so just rename the node in
+            // the macro input
+            NameLike::NameRef(name_ref) if name_ref.syntax().text_range() == reference.range => {
+                source_edit_from_name_ref(name_ref, new_name, def)
+            }
+            NameLike::Name(name) if name.syntax().text_range() == reference.range => {
+                source_edit_from_name(name, new_name)
+            }
+            _ => None,
+        }
+        .unwrap_or_else(|| (reference.range, new_name.to_string()));
+        edit.replace(range, replacement);
     }
     (file_id, edit.finish())
 }
 
+fn source_edit_from_name(name: &ast::Name, new_name: &str) -> Option<(TextRange, String)> {
+    if let Some(_) = ast::RecordPatField::for_field_name(name) {
+        if let Some(ident_pat) = name.syntax().parent().and_then(ast::IdentPat::cast) {
+            return Some((
+                TextRange::empty(ident_pat.syntax().text_range().start()),
+                format!("{}: ", new_name),
+            ));
+        }
+    }
+    None
+}
+
 fn source_edit_from_name_ref(
     name_ref: &ast::NameRef,
     new_name: &str,
     def: Definition,
-) -> (Option<TextRange>, String) {
+) -> Option<(TextRange, String)> {
     if let Some(record_field) = ast::RecordExprField::for_name_ref(name_ref) {
         let rcf_name_ref = record_field.name_ref();
         let rcf_expr = record_field.expr();
@@ -197,45 +227,40 @@ fn source_edit_from_name_ref(
                 if field_name == *name_ref {
                     if init.text() == new_name {
                         mark::hit!(test_rename_field_put_init_shorthand);
-                        // same names, we can use a shorthand here instead
+                        // same names, we can use a shorthand here instead.
                         // we do not want to erase attributes hence this range start
                         let s = field_name.syntax().text_range().start();
                         let e = record_field.syntax().text_range().end();
-                        return (Some(TextRange::new(s, e)), format!("{}", new_name));
+                        return Some((TextRange::new(s, e), new_name.to_owned()));
                     }
                 } else if init == *name_ref {
                     if field_name.text() == new_name {
                         mark::hit!(test_rename_local_put_init_shorthand);
-                        // same names, we can use a shorthand here instead
+                        // same names, we can use a shorthand here instead.
                         // we do not want to erase attributes hence this range start
                         let s = field_name.syntax().text_range().start();
                         let e = record_field.syntax().text_range().end();
-                        return (Some(TextRange::new(s, e)), format!("{}", new_name));
+                        return Some((TextRange::new(s, e), new_name.to_owned()));
                     }
                 }
+                None
             }
             // init shorthand
-            (None, Some(_)) => {
-                // FIXME: instead of splitting the shorthand, recursively trigger a rename of the
-                // other name https://github.com/rust-analyzer/rust-analyzer/issues/6547
-                match def {
-                    Definition::Field(_) => {
-                        mark::hit!(test_rename_field_in_field_shorthand);
-                        let s = name_ref.syntax().text_range().start();
-                        return (Some(TextRange::empty(s)), format!("{}: ", new_name));
-                    }
-                    Definition::Local(_) => {
-                        mark::hit!(test_rename_local_in_field_shorthand);
-                        let s = name_ref.syntax().text_range().end();
-                        return (Some(TextRange::empty(s)), format!(": {}", new_name));
-                    }
-                    _ => {}
-                }
+            // FIXME: instead of splitting the shorthand, recursively trigger a rename of the
+            // other name https://github.com/rust-analyzer/rust-analyzer/issues/6547
+            (None, Some(_)) if matches!(def, Definition::Field(_)) => {
+                mark::hit!(test_rename_field_in_field_shorthand);
+                let s = name_ref.syntax().text_range().start();
+                Some((TextRange::empty(s), format!("{}: ", new_name)))
             }
-            _ => {}
+            (None, Some(_)) if matches!(def, Definition::Local(_)) => {
+                mark::hit!(test_rename_local_in_field_shorthand);
+                let s = name_ref.syntax().text_range().end();
+                Some((TextRange::empty(s), format!(": {}", new_name)))
+            }
+            _ => None,
         }
-    }
-    if let Some(record_field) = ast::RecordPatField::for_field_name_ref(name_ref) {
+    } else if let Some(record_field) = ast::RecordPatField::for_field_name_ref(name_ref) {
         let rcf_name_ref = record_field.name_ref();
         let rcf_pat = record_field.pat();
         match (rcf_name_ref, rcf_pat) {
@@ -244,17 +269,20 @@ fn source_edit_from_name_ref(
                 // field name is being renamed
                 if pat.name().map_or(false, |it| it.text() == new_name) {
                     mark::hit!(test_rename_field_put_init_shorthand_pat);
-                    // same names, we can use a shorthand here instead
+                    // same names, we can use a shorthand here instead/
                     // we do not want to erase attributes hence this range start
                     let s = field_name.syntax().text_range().start();
                     let e = record_field.syntax().text_range().end();
-                    return (Some(TextRange::new(s, e)), format!("{}", new_name));
+                    Some((TextRange::new(s, e), pat.to_string()))
+                } else {
+                    None
                 }
             }
-            _ => {}
+            _ => None,
         }
+    } else {
+        None
     }
-    (None, format!("{}", new_name))
 }
 
 fn rename_mod(
@@ -1477,7 +1505,7 @@ fn foo(i: i32) -> Foo {
     }
 
     #[test]
-    fn test_struct_field_destructure_into_shorthand() {
+    fn test_struct_field_pat_into_shorthand() {
         mark::check!(test_rename_field_put_init_shorthand_pat);
         check(
             "baz",
@@ -1485,16 +1513,16 @@ fn foo(i: i32) -> Foo {
 struct Foo { i$0: i32 }
 
 fn foo(foo: Foo) {
-    let Foo { i: baz } = foo;
-    let _ = baz;
+    let Foo { i: ref baz @ qux } = foo;
+    let _ = qux;
 }
 "#,
             r#"
 struct Foo { baz: i32 }
 
 fn foo(foo: Foo) {
-    let Foo { baz } = foo;
-    let _ = baz;
+    let Foo { ref baz @ qux } = foo;
+    let _ = qux;
 }
 "#,
         );
@@ -1568,6 +1596,27 @@ fn foo(Foo { i: bar }: foo) -> i32 {
     }
 
     #[test]
+    fn test_struct_field_complex_ident_pat() {
+        check(
+            "baz",
+            r#"
+struct Foo { i$0: i32 }
+
+fn foo(foo: Foo) {
+    let Foo { ref i } = foo;
+}
+"#,
+            r#"
+struct Foo { baz: i32 }
+
+fn foo(foo: Foo) {
+    let Foo { baz: ref i } = foo;
+}
+"#,
+        );
+    }
+
+    #[test]
     fn test_rename_lifetimes() {
         mark::check!(rename_lifetime);
         check(
@@ -1674,4 +1723,38 @@ impl Foo {
 "#,
         )
     }
+
+    #[test]
+    fn test_rename_field_in_pat_in_macro_doesnt_shorthand() {
+        // ideally we would be able to make this emit a short hand, but I doubt this is easily possible
+        check(
+            "baz",
+            r#"
+macro_rules! foo {
+    ($pattern:pat) => {
+        let $pattern = loop {};
+    };
+}
+struct Foo {
+    bar$0: u32,
+}
+fn foo() {
+    foo!(Foo { bar: baz });
+}
+"#,
+            r#"
+macro_rules! foo {
+    ($pattern:pat) => {
+        let $pattern = loop {};
+    };
+}
+struct Foo {
+    baz: u32,
+}
+fn foo() {
+    foo!(Foo { baz: baz });
+}
+"#,
+        )
+    }
 }
diff --git a/crates/ide_db/src/defs.rs b/crates/ide_db/src/defs.rs
index a8091dbee..ff612b7d0 100644
--- a/crates/ide_db/src/defs.rs
+++ b/crates/ide_db/src/defs.rs
@@ -6,8 +6,8 @@
 // FIXME: this badly needs rename/rewrite (matklad, 2020-02-06).
 
 use hir::{
-    db::HirDatabase, Crate, Field, GenericParam, HasVisibility, Impl, Label, Local, MacroDef,
-    Module, ModuleDef, Name, PathResolution, Semantics, Visibility,
+    db::HirDatabase, Crate, Field, GenericParam, HasAttrs, HasVisibility, Impl, Label, Local,
+    MacroDef, Module, ModuleDef, Name, PathResolution, Semantics, Visibility,
 };
 use syntax::{
     ast::{self, AstNode, PathSegmentKind},
@@ -366,7 +366,15 @@ impl NameRefClass {
 
         if let Some(path) = name_ref.syntax().ancestors().find_map(ast::Path::cast) {
             if let Some(resolved) = sema.resolve_path(&path) {
-                return Some(NameRefClass::Definition(resolved.into()));
+                if path.syntax().parent().and_then(ast::Attr::cast).is_some() {
+                    if let PathResolution::Def(ModuleDef::Function(func)) = resolved {
+                        if func.attrs(sema.db).by_key("proc_macro_attribute").exists() {
+                            return Some(NameRefClass::Definition(resolved.into()));
+                        }
+                    }
+                } else {
+                    return Some(NameRefClass::Definition(resolved.into()));
+                }
             }
         }
 
diff --git a/crates/project_model/src/cargo_workspace.rs b/crates/project_model/src/cargo_workspace.rs
index f47898b9b..1d8d34a0b 100644
--- a/crates/project_model/src/cargo_workspace.rs
+++ b/crates/project_model/src/cargo_workspace.rs
@@ -44,6 +44,15 @@ impl ops::Index<Target> for CargoWorkspace {
     }
 }
 
+/// Describes how to set the rustc source directory.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum RustcSource {
+    /// Explicit path for the rustc source directory.
+    Path(AbsPathBuf),
+    /// Try to automatically detect where the rustc source directory is.
+    Discover,
+}
+
 #[derive(Default, Clone, Debug, PartialEq, Eq)]
 pub struct CargoConfig {
     /// Do not activate the `default` feature.
@@ -64,7 +73,7 @@ pub struct CargoConfig {
     pub no_sysroot: bool,
 
     /// rustc private crate source
-    pub rustc_source: Option<AbsPathBuf>,
+    pub rustc_source: Option<RustcSource>,
 }
 
 pub type Package = Idx<PackageData>;
diff --git a/crates/project_model/src/lib.rs b/crates/project_model/src/lib.rs
index d712095a6..a5b35ed95 100644
--- a/crates/project_model/src/lib.rs
+++ b/crates/project_model/src/lib.rs
@@ -21,8 +21,8 @@ use rustc_hash::FxHashSet;
 pub use crate::{
     build_data::{BuildDataCollector, BuildDataResult},
     cargo_workspace::{
-        CargoConfig, CargoWorkspace, Package, PackageData, PackageDependency, Target, TargetData,
-        TargetKind,
+        CargoConfig, CargoWorkspace, Package, PackageData, PackageDependency, RustcSource, Target,
+        TargetData, TargetKind,
     },
     project_json::{ProjectJson, ProjectJsonData},
     sysroot::Sysroot,
diff --git a/crates/project_model/src/sysroot.rs b/crates/project_model/src/sysroot.rs
index ff44dae4a..3b0ff506d 100644
--- a/crates/project_model/src/sysroot.rs
+++ b/crates/project_model/src/sysroot.rs
@@ -51,11 +51,18 @@ impl Sysroot {
     pub fn discover(cargo_toml: &AbsPath) -> Result<Sysroot> {
         log::debug!("Discovering sysroot for {}", cargo_toml.display());
         let current_dir = cargo_toml.parent().unwrap();
-        let sysroot_src_dir = discover_sysroot_src_dir(current_dir)?;
+        let sysroot_dir = discover_sysroot_dir(current_dir)?;
+        let sysroot_src_dir = discover_sysroot_src_dir(&sysroot_dir, current_dir)?;
         let res = Sysroot::load(&sysroot_src_dir)?;
         Ok(res)
     }
 
+    pub fn discover_rustc(cargo_toml: &AbsPath) -> Option<AbsPathBuf> {
+        log::debug!("Discovering rustc source for {}", cargo_toml.display());
+        let current_dir = cargo_toml.parent().unwrap();
+        discover_sysroot_dir(current_dir).ok().and_then(|sysroot_dir| get_rustc_src(&sysroot_dir))
+    }
+
     pub fn load(sysroot_src_dir: &AbsPath) -> Result<Sysroot> {
         let mut sysroot = Sysroot { crates: Arena::default() };
 
@@ -110,7 +117,18 @@ impl Sysroot {
     }
 }
 
-fn discover_sysroot_src_dir(current_dir: &AbsPath) -> Result<AbsPathBuf> {
+fn discover_sysroot_dir(current_dir: &AbsPath) -> Result<AbsPathBuf> {
+    let mut rustc = Command::new(toolchain::rustc());
+    rustc.current_dir(current_dir).args(&["--print", "sysroot"]);
+    log::debug!("Discovering sysroot by {:?}", rustc);
+    let stdout = utf8_stdout(rustc)?;
+    Ok(AbsPathBuf::assert(PathBuf::from(stdout)))
+}
+
+fn discover_sysroot_src_dir(
+    sysroot_path: &AbsPathBuf,
+    current_dir: &AbsPath,
+) -> Result<AbsPathBuf> {
     if let Ok(path) = env::var("RUST_SRC_PATH") {
         let path = AbsPathBuf::try_from(path.as_str())
             .map_err(|path| format_err!("RUST_SRC_PATH must be absolute: {}", path.display()))?;
@@ -122,14 +140,6 @@ fn discover_sysroot_src_dir(current_dir: &AbsPath) -> Result<AbsPathBuf> {
         log::debug!("RUST_SRC_PATH is set, but is invalid (no core: {:?}), ignoring", core);
     }
 
-    let sysroot_path = {
-        let mut rustc = Command::new(toolchain::rustc());
-        rustc.current_dir(current_dir).args(&["--print", "sysroot"]);
-        log::debug!("Discovering sysroot by {:?}", rustc);
-        let stdout = utf8_stdout(rustc)?;
-        AbsPathBuf::assert(PathBuf::from(stdout))
-    };
-
     get_rust_src(&sysroot_path)
         .or_else(|| {
             let mut rustup = Command::new(toolchain::rustup());
@@ -149,6 +159,16 @@ try installing the Rust source the same way you installed rustc",
         })
 }
 
+fn get_rustc_src(sysroot_path: &AbsPath) -> Option<AbsPathBuf> {
+    let rustc_src = sysroot_path.join("lib/rustlib/rustc-src/rust/compiler/rustc/Cargo.toml");
+    log::debug!("Checking for rustc source code: {}", rustc_src.display());
+    if rustc_src.exists() {
+        Some(rustc_src)
+    } else {
+        None
+    }
+}
+
 fn get_rust_src(sysroot_path: &AbsPath) -> Option<AbsPathBuf> {
     // Try the new path first since the old one still exists.
     let rust_src = sysroot_path.join("lib/rustlib/src/rust");
diff --git a/crates/project_model/src/workspace.rs b/crates/project_model/src/workspace.rs
index c30861976..0220efdb4 100644
--- a/crates/project_model/src/workspace.rs
+++ b/crates/project_model/src/workspace.rs
@@ -114,6 +114,7 @@ impl ProjectWorkspace {
                             cargo_version
                         )
                     })?;
+
                 let sysroot = if config.no_sysroot {
                     Sysroot::default()
                 } else {
@@ -125,7 +126,17 @@ impl ProjectWorkspace {
                     })?
                 };
 
-                let rustc = if let Some(rustc_dir) = &config.rustc_source {
+                let rustc_dir = if let Some(rustc_source) = &config.rustc_source {
+                    use cargo_workspace::RustcSource;
+                    match rustc_source {
+                        RustcSource::Path(path) => Some(path.clone()),
+                        RustcSource::Discover => Sysroot::discover_rustc(&cargo_toml),
+                    }
+                } else {
+                    None
+                };
+
+                let rustc = if let Some(rustc_dir) = rustc_dir {
                     Some(
                         CargoWorkspace::from_cargo_metadata(&rustc_dir, config, progress)
                             .with_context(|| {
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index cc0b22bff..f9098968a 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -18,7 +18,7 @@ use ide_db::helpers::{
 };
 use itertools::Itertools;
 use lsp_types::{ClientCapabilities, MarkupKind};
-use project_model::{CargoConfig, ProjectJson, ProjectJsonData, ProjectManifest};
+use project_model::{CargoConfig, ProjectJson, ProjectJsonData, ProjectManifest, RustcSource};
 use rustc_hash::FxHashSet;
 use serde::{de::DeserializeOwned, Deserialize};
 use vfs::AbsPathBuf;
@@ -177,8 +177,9 @@ config_data! {
         /// tests or binaries.\nFor example, it may be `--release`.
         runnables_cargoExtraArgs: Vec<String>   = "[]",
 
-        /// Path to the rust compiler sources, for usage in rustc_private projects.
-        rustcSource : Option<PathBuf> = "null",
+        /// Path to the rust compiler sources, for usage in rustc_private projects, or "discover"
+        /// to try to automatically find it.
+        rustcSource : Option<String> = "null",
 
         /// Additional arguments to `rustfmt`.
         rustfmt_extraArgs: Vec<String>               = "[]",
@@ -473,7 +474,13 @@ impl Config {
         self.data.cargo_loadOutDirsFromCheck
     }
     pub fn cargo(&self) -> CargoConfig {
-        let rustc_source = self.data.rustcSource.as_ref().map(|it| self.root_path.join(&it));
+        let rustc_source = self.data.rustcSource.as_ref().map(|rustc_src| {
+            if rustc_src == "discover" {
+                RustcSource::Discover
+            } else {
+                RustcSource::Path(self.root_path.join(rustc_src))
+            }
+        });
 
         CargoConfig {
             no_default_features: self.data.cargo_noDefaultFeatures,
diff --git a/crates/syntax/src/ast/node_ext.rs b/crates/syntax/src/ast/node_ext.rs
index b105cb0e0..307e150e9 100644
--- a/crates/syntax/src/ast/node_ext.rs
+++ b/crates/syntax/src/ast/node_ext.rs
@@ -3,12 +3,11 @@
 
 use std::fmt;
 
-use ast::AttrsOwner;
 use itertools::Itertools;
 use parser::SyntaxKind;
 
 use crate::{
-    ast::{self, support, AstNode, AstToken, NameOwner, SyntaxNode},
+    ast::{self, support, AstNode, AstToken, AttrsOwner, NameOwner, SyntaxNode},
     SmolStr, SyntaxElement, SyntaxToken, T,
 };
 
@@ -324,7 +323,7 @@ impl ast::RecordPatField {
 
     pub fn for_field_name(field_name: &ast::Name) -> Option<ast::RecordPatField> {
         let candidate =
-            field_name.syntax().ancestors().nth(3).and_then(ast::RecordPatField::cast)?;
+            field_name.syntax().ancestors().nth(2).and_then(ast::RecordPatField::cast)?;
         match candidate.field_name()? {
             NameOrNameRef::Name(name) if name == *field_name => Some(candidate),
             _ => None,
diff --git a/docs/user/generated_config.adoc b/docs/user/generated_config.adoc
index 55178c84c..f91e04c31 100644
--- a/docs/user/generated_config.adoc
+++ b/docs/user/generated_config.adoc
@@ -105,7 +105,7 @@
 [[rust-analyzer.runnables.cargoExtraArgs]]rust-analyzer.runnables.cargoExtraArgs (default: `[]`)::
  Additional arguments to be passed to cargo for runnables such as  tests or binaries.\nFor example, it may be `--release`.
 [[rust-analyzer.rustcSource]]rust-analyzer.rustcSource (default: `null`)::
- Path to the rust compiler sources, for usage in rustc_private projects.
+ Path to the rust compiler sources, for usage in rustc_private projects, or "discover"  to try to automatically find it.
 [[rust-analyzer.rustfmt.extraArgs]]rust-analyzer.rustfmt.extraArgs (default: `[]`)::
  Additional arguments to `rustfmt`.
 [[rust-analyzer.rustfmt.overrideCommand]]rust-analyzer.rustfmt.overrideCommand (default: `null`)::
diff --git a/editors/code/package.json b/editors/code/package.json
index 55825456e..defa108cb 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -707,7 +707,7 @@
                     }
                 },
                 "rust-analyzer.rustcSource": {
-                    "markdownDescription": "Path to the rust compiler sources, for usage in rustc_private projects.",
+                    "markdownDescription": "Path to the rust compiler sources, for usage in rustc_private projects, or \"discover\" to try to automatically find it.",
                     "default": null,
                     "type": [
                         "null",