112 files changed, 3591 insertions, 2358 deletions
diff --git a/crates/assists/src/handlers/extract_struct_from_enum_variant.rs b/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
index 40028fc01..e3ef04932 100644
--- a/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
+++ b/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
@@ -2,12 +2,16 @@ use std::iter;
 use either::Either;
 use hir::{AsName, Module, ModuleDef, Name, Variant};
-use ide_db::helpers::{
+use ide_db::{
-    insert_use::{insert_use, ImportScope},
+    defs::Definition,
-    mod_path_to_ast,
+    helpers::{
+        insert_use::{insert_use, ImportScope},
+        mod_path_to_ast,
+    },
+    search::FileReference,
+    RootDatabase,
 };
-use ide_db::{defs::Definition, search::Reference, RootDatabase};
+use rustc_hash::FxHashSet;
-use rustc_hash::{FxHashMap, FxHashSet};
 use syntax::{
    algo::{find_node_at_offset, SyntaxRewriter},
    ast::{self, edit::IndentLevel, make, AstNode, NameOwner, VisibilityOwner},
@@ -58,29 +62,29 @@ pub(crate) fn extract_struct_from_enum_variant(
            let mut visited_modules_set = FxHashSet::default();
            let current_module = enum_hir.module(ctx.db());
            visited_modules_set.insert(current_module);
-            let mut rewriters = FxHashMap::default();
+            let mut def_rewriter = None;
-            for reference in usages {
+            for (file_id, references) in usages {
-                let rewriter = rewriters
+                let mut rewriter = SyntaxRewriter::default();
-                    .entry(reference.file_range.file_id)
+                let source_file = ctx.sema.parse(file_id);
-                    .or_insert_with(SyntaxRewriter::default);
+                for reference in references {
-                let source_file = ctx.sema.parse(reference.file_range.file_id);
+                    update_reference(
-                update_reference(
+                        ctx,
-                    ctx,
+                        &mut rewriter,
-                    rewriter,
+                        reference,
-                    reference,
+                        &source_file,
-                    &source_file,
+                        &enum_module_def,
-                    &enum_module_def,
+                        &variant_hir_name,
-                    &variant_hir_name,
+                        &mut visited_modules_set,
-                    &mut visited_modules_set,
+                    );
-                );
+                }
-            }
+                if file_id == ctx.frange.file_id {
-            let mut rewriter =
+                    def_rewriter = Some(rewriter);
-                rewriters.remove(&ctx.frange.file_id).unwrap_or_else(SyntaxRewriter::default);
+                    continue;
-            for (file_id, rewriter) in rewriters {
+                }
                builder.edit_file(file_id);
                builder.rewrite(rewriter);
            }
-            builder.edit_file(ctx.frange.file_id);
+            let mut rewriter = def_rewriter.unwrap_or_default();
            update_variant(&mut rewriter, &variant);
            extract_struct_def(
                &mut rewriter,
@@ -90,6 +94,7 @@ pub(crate) fn extract_struct_from_enum_variant(
                &variant.parent_enum().syntax().clone().into(),
                enum_ast.visibility(),
            );
+            builder.edit_file(ctx.frange.file_id);
            builder.rewrite(rewriter);
        },
    )
@@ -205,13 +210,13 @@ fn update_variant(rewriter: &mut SyntaxRewriter, variant: &ast::Variant) -> Opti
 fn update_reference(
    ctx: &AssistContext,
    rewriter: &mut SyntaxRewriter,
-    reference: Reference,
+    reference: FileReference,
    source_file: &SourceFile,
    enum_module_def: &ModuleDef,
    variant_hir_name: &Name,
    visited_modules_set: &mut FxHashSet<Module>,
 ) -> Option<()> {
-    let offset = reference.file_range.range.start();
+    let offset = reference.range.start();
    let (segment, expr) = if let Some(path_expr) =
        find_node_at_offset::<ast::PathExpr>(source_file.syntax(), offset)
    {
diff --git a/crates/assists/src/handlers/inline_local_variable.rs b/crates/assists/src/handlers/inline_local_variable.rs
index d559be9cb..dc798daaa 100644
--- a/crates/assists/src/handlers/inline_local_variable.rs
+++ b/crates/assists/src/handlers/inline_local_variable.rs
@@ -1,4 +1,7 @@
-use ide_db::{defs::Definition, search::ReferenceKind};
+use ide_db::{
+    defs::Definition,
+    search::{FileReference, ReferenceKind},
+};
 use syntax::{
    ast::{self, AstNode, AstToken},
    TextRange,
@@ -44,8 +47,8 @@ pub(crate) fn inline_local_variable(acc: &mut Assists, ctx: &AssistContext) -> O
    let def = ctx.sema.to_def(&bind_pat)?;
    let def = Definition::Local(def);
-    let refs = def.usages(&ctx.sema).all();
+    let usages = def.usages(&ctx.sema).all();
-    if refs.is_empty() {
+    if usages.is_empty() {
        mark::hit!(test_not_applicable_if_variable_unused);
        return None;
    };
@@ -63,48 +66,45 @@ pub(crate) fn inline_local_variable(acc: &mut Assists, ctx: &AssistContext) -> O
        let_stmt.syntax().text_range()
    };
-    let mut wrap_in_parens = vec![true; refs.len()];
+    let wrap_in_parens = usages
+        .references
-    for (i, desc) in refs.iter().enumerate() {
+        .values()
-        let usage_node = ctx
+        .flatten()
-            .covering_node_for_range(desc.file_range.range)
+        .map(|&FileReference { range, .. }| {
-            .ancestors()
+            let usage_node =
-            .find_map(ast::PathExpr::cast)?;
+                ctx.covering_node_for_range(range).ancestors().find_map(ast::PathExpr::cast)?;
-        let usage_parent_option = usage_node.syntax().parent().and_then(ast::Expr::cast);
+            let usage_parent_option = usage_node.syntax().parent().and_then(ast::Expr::cast);
-        let usage_parent = match usage_parent_option {
+            let usage_parent = match usage_parent_option {
-            Some(u) => u,
+                Some(u) => u,
-            None => {
+                None => return Ok(false),
-                wrap_in_parens[i] = false;
+            };
-                continue;
-            }
+            Ok(!matches!((&initializer_expr, usage_parent),
-        };
+                (ast::Expr::CallExpr(_), _)
+                | (ast::Expr::IndexExpr(_), _)
-        wrap_in_parens[i] = match (&initializer_expr, usage_parent) {
+                | (ast::Expr::MethodCallExpr(_), _)
-            (ast::Expr::CallExpr(_), _)
+                | (ast::Expr::FieldExpr(_), _)
-            | (ast::Expr::IndexExpr(_), _)
+                | (ast::Expr::TryExpr(_), _)
-            | (ast::Expr::MethodCallExpr(_), _)
+                | (ast::Expr::RefExpr(_), _)
-            | (ast::Expr::FieldExpr(_), _)
+                | (ast::Expr::Literal(_), _)
-            | (ast::Expr::TryExpr(_), _)
+                | (ast::Expr::TupleExpr(_), _)
-            | (ast::Expr::RefExpr(_), _)
+                | (ast::Expr::ArrayExpr(_), _)
-            | (ast::Expr::Literal(_), _)
+                | (ast::Expr::ParenExpr(_), _)
-            | (ast::Expr::TupleExpr(_), _)
+                | (ast::Expr::PathExpr(_), _)
-            | (ast::Expr::ArrayExpr(_), _)
+                | (ast::Expr::BlockExpr(_), _)
-            | (ast::Expr::ParenExpr(_), _)
+                | (ast::Expr::EffectExpr(_), _)
-            | (ast::Expr::PathExpr(_), _)
+                | (_, ast::Expr::CallExpr(_))
-            | (ast::Expr::BlockExpr(_), _)
+                | (_, ast::Expr::TupleExpr(_))
-            | (ast::Expr::EffectExpr(_), _)
+                | (_, ast::Expr::ArrayExpr(_))
-            | (_, ast::Expr::CallExpr(_))
+                | (_, ast::Expr::ParenExpr(_))
-            | (_, ast::Expr::TupleExpr(_))
+                | (_, ast::Expr::ForExpr(_))
-            | (_, ast::Expr::ArrayExpr(_))
+                | (_, ast::Expr::WhileExpr(_))
-            | (_, ast::Expr::ParenExpr(_))
+                | (_, ast::Expr::BreakExpr(_))
-            | (_, ast::Expr::ForExpr(_))
+                | (_, ast::Expr::ReturnExpr(_))
-            | (_, ast::Expr::WhileExpr(_))
+                | (_, ast::Expr::MatchExpr(_))
-            | (_, ast::Expr::BreakExpr(_))
+            ))
-            | (_, ast::Expr::ReturnExpr(_))
+        })
-            | (_, ast::Expr::MatchExpr(_)) => false,
+        .collect::<Result<Vec<_>, _>>()?;
-            _ => true,
-        };
-    }
    let init_str = initializer_expr.syntax().text().to_string();
    let init_in_paren = format!("({})", &init_str);
@@ -116,15 +116,16 @@ pub(crate) fn inline_local_variable(acc: &mut Assists, ctx: &AssistContext) -> O
        target,
        move |builder| {
            builder.delete(delete_range);
-            for (desc, should_wrap) in refs.iter().zip(wrap_in_parens) {
+            for (reference, should_wrap) in usages.references.values().flatten().zip(wrap_in_parens)
+            {
                let replacement =
                    if should_wrap { init_in_paren.clone() } else { init_str.clone() };
-                match desc.kind {
+                match reference.kind {
                    ReferenceKind::FieldShorthandForLocal => {
                        mark::hit!(inline_field_shorthand);
-                        builder.insert(desc.file_range.range.end(), format!(": {}", replacement))
+                        builder.insert(reference.range.end(), format!(": {}", replacement))
                    }
-                    _ => builder.replace(desc.file_range.range, replacement),
+                    _ => builder.replace(reference.range, replacement),
                }
            }
        },
diff --git a/crates/assists/src/handlers/remove_dbg.rs b/crates/assists/src/handlers/remove_dbg.rs
index 0320c2f12..6114091f2 100644
--- a/crates/assists/src/handlers/remove_dbg.rs
+++ b/crates/assists/src/handlers/remove_dbg.rs
@@ -1,6 +1,6 @@
 use syntax::{
    ast::{self, AstNode},
-    match_ast, SyntaxElement, SyntaxKind, TextRange, TextSize, T,
+    match_ast, SyntaxElement, TextRange, TextSize, T,
 };
 use crate::{AssistContext, AssistId, AssistKind, Assists};
@@ -136,14 +136,14 @@ fn needs_parentheses_around_macro_contents(macro_contents: Vec<SyntaxElement>) -
            symbol_kind => {
                let symbol_not_in_bracket = unpaired_brackets_in_contents.is_empty();
                if symbol_not_in_bracket
-                    && symbol_kind != SyntaxKind::COLON // paths
+                    && symbol_kind != T![:] // paths
-                    && (symbol_kind != SyntaxKind::DOT // field/method access
+                    && (symbol_kind != T![.] // field/method access
                        || macro_contents // range expressions consist of two SyntaxKind::Dot in macro invocations
                            .peek()
-                            .map(|element| element.kind() == SyntaxKind::DOT)
+                            .map(|element| element.kind() == T![.])
                            .unwrap_or(false))
-                    && symbol_kind != SyntaxKind::QUESTION // try operator
+                    && symbol_kind != T![?] // try operator
-                    && (symbol_kind.is_punct() || symbol_kind == SyntaxKind::AS_KW)
+                    && (symbol_kind.is_punct() || symbol_kind == T![as])
                {
                    return true;
                }
diff --git a/crates/assists/src/handlers/remove_unused_param.rs b/crates/assists/src/handlers/remove_unused_param.rs
index 56e8b5229..c961680e2 100644
--- a/crates/assists/src/handlers/remove_unused_param.rs
+++ b/crates/assists/src/handlers/remove_unused_param.rs
@@ -1,8 +1,8 @@
-use ide_db::{defs::Definition, search::Reference};
+use ide_db::{base_db::FileId, defs::Definition, search::FileReference};
 use syntax::{
    algo::find_node_at_range,
    ast::{self, ArgListOwner},
-    AstNode, SyntaxKind, SyntaxNode, TextRange, T,
+    AstNode, SourceFile, SyntaxKind, SyntaxNode, TextRange, T,
 };
 use test_utils::mark;
 use SyntaxKind::WHITESPACE;
@@ -58,32 +58,41 @@ pub(crate) fn remove_unused_param(acc: &mut Assists, ctx: &AssistContext) -> Opt
        param.syntax().text_range(),
        |builder| {
            builder.delete(range_to_remove(param.syntax()));
-            for usage in fn_def.usages(&ctx.sema).all() {
+            for (file_id, references) in fn_def.usages(&ctx.sema).all() {
-                process_usage(ctx, builder, usage, param_position);
+                process_usages(ctx, builder, file_id, references, param_position);
            }
        },
    )
 }
-fn process_usage(
+fn process_usages(
    ctx: &AssistContext,
    builder: &mut AssistBuilder,
-    usage: Reference,
+    file_id: FileId,
+    references: Vec<FileReference>,
    arg_to_remove: usize,
-) -> Option<()> {
+) {
-    let source_file = ctx.sema.parse(usage.file_range.file_id);
+    let source_file = ctx.sema.parse(file_id);
-    let call_expr: ast::CallExpr =
+    builder.edit_file(file_id);
-        find_node_at_range(source_file.syntax(), usage.file_range.range)?;
+    for usage in references {
+        if let Some(text_range) = process_usage(&source_file, usage, arg_to_remove) {
+            builder.delete(text_range);
+        }
+    }
+}
+fn process_usage(
+    source_file: &SourceFile,
+    FileReference { range, .. }: FileReference,
+    arg_to_remove: usize,
+) -> Option<TextRange> {
+    let call_expr: ast::CallExpr = find_node_at_range(source_file.syntax(), range)?;
    let call_expr_range = call_expr.expr()?.syntax().text_range();
-    if !call_expr_range.contains_range(usage.file_range.range) {
+    if !call_expr_range.contains_range(range) {
        return None;
    }
    let arg = call_expr.arg_list()?.args().nth(arg_to_remove)?;
+    Some(range_to_remove(arg.syntax()))
-    builder.edit_file(usage.file_range.file_id);
-    builder.delete(range_to_remove(arg.syntax()));
-    Some(())
 }
 fn range_to_remove(node: &SyntaxNode) -> TextRange {
diff --git a/crates/assists/src/handlers/reorder_impl.rs b/crates/assists/src/handlers/reorder_impl.rs
new file mode 100644
index 000000000..309f291c8
--- /dev/null
+++ b/crates/assists/src/handlers/reorder_impl.rs
@@ -0,0 +1,201 @@
+use itertools::Itertools;
+use rustc_hash::FxHashMap;
+use hir::{PathResolution, Semantics};
+use ide_db::RootDatabase;
+use syntax::{
+    algo,
+    ast::{self, NameOwner},
+    AstNode,
+};
+use test_utils::mark;
+use crate::{AssistContext, AssistId, AssistKind, Assists};
+// Assist: reorder_impl
+//
+// Reorder the methods of an `impl Trait`. The methods will be ordered
+// in the same order as in the trait definition.
+//
+// ```
+// trait Foo {
+//     fn a() {}
+//     fn b() {}
+//     fn c() {}
+// }
+//
+// struct Bar;
+// $0impl Foo for Bar {
+//     fn b() {}
+//     fn c() {}
+//     fn a() {}
+// }
+// ```
+// ->
+// ```
+// trait Foo {
+//     fn a() {}
+//     fn b() {}
+//     fn c() {}
+// }
+//
+// struct Bar;
+// impl Foo for Bar {
+//     fn a() {}
+//     fn b() {}
+//     fn c() {}
+// }
+// ```
+//
+pub(crate) fn reorder_impl(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let impl_ast = ctx.find_node_at_offset::<ast::Impl>()?;
+    let items = impl_ast.assoc_item_list()?;
+    let methods = get_methods(&items);
+    let path = impl_ast
+        .trait_()
+        .and_then(|t| match t {
+            ast::Type::PathType(path) => Some(path),
+            _ => None,
+        })?
+        .path()?;
+    let ranks = compute_method_ranks(&path, ctx)?;
+    let sorted: Vec<_> = methods
+        .iter()
+        .cloned()
+        .sorted_by_key(|f| {
+            f.name().and_then(|n| ranks.get(&n.to_string()).copied()).unwrap_or(usize::max_value())
+        })
+        .collect();
+    // Don't edit already sorted methods:
+    if methods == sorted {
+        mark::hit!(not_applicable_if_sorted);
+        return None;
+    }
+    let target = items.syntax().text_range();
+    acc.add(AssistId("reorder_impl", AssistKind::RefactorRewrite), "Sort methods", target, |edit| {
+        let mut rewriter = algo::SyntaxRewriter::default();
+        for (old, new) in methods.iter().zip(&sorted) {
+            rewriter.replace(old.syntax(), new.syntax());
+        }
+        edit.rewrite(rewriter);
+    })
+}
+fn compute_method_ranks(path: &ast::Path, ctx: &AssistContext) -> Option<FxHashMap<String, usize>> {
+    let td = trait_definition(path, &ctx.sema)?;
+    Some(
+        td.items(ctx.db())
+            .iter()
+            .flat_map(|i| match i {
+                hir::AssocItem::Function(f) => Some(f),
+                _ => None,
+            })
+            .enumerate()
+            .map(|(idx, func)| ((func.name(ctx.db()).to_string(), idx)))
+            .collect(),
+    )
+}
+fn trait_definition(path: &ast::Path, sema: &Semantics<RootDatabase>) -> Option<hir::Trait> {
+    match sema.resolve_path(path)? {
+        PathResolution::Def(hir::ModuleDef::Trait(trait_)) => Some(trait_),
+        _ => None,
+    }
+}
+fn get_methods(items: &ast::AssocItemList) -> Vec<ast::Fn> {
+    items
+        .assoc_items()
+        .flat_map(|i| match i {
+            ast::AssocItem::Fn(f) => Some(f),
+            _ => None,
+        })
+        .filter(|f| f.name().is_some())
+        .collect()
+}
+#[cfg(test)]
+mod tests {
+    use test_utils::mark;
+    use crate::tests::{check_assist, check_assist_not_applicable};
+    use super::*;
+    #[test]
+    fn not_applicable_if_sorted() {
+        mark::check!(not_applicable_if_sorted);
+        check_assist_not_applicable(
+            reorder_impl,
+            r#"
+trait Bar {
+    fn a() {}
+    fn z() {}
+    fn b() {}
+}
+struct Foo;
+$0impl Bar for Foo {
+    fn a() {}
+    fn z() {}
+    fn b() {}
+}
+        "#,
+        )
+    }
+    #[test]
+    fn not_applicable_if_empty() {
+        check_assist_not_applicable(
+            reorder_impl,
+            r#"
+trait Bar {};
+struct Foo;
+$0impl Bar for Foo {}
+        "#,
+        )
+    }
+    #[test]
+    fn reorder_impl_trait_methods() {
+        check_assist(
+            reorder_impl,
+            r#"
+trait Bar {
+    fn a() {}
+    fn c() {}
+    fn b() {}
+    fn d() {}
+}
+struct Foo;
+$0impl Bar for Foo {
+    fn d() {}
+    fn b() {}
+    fn c() {}
+    fn a() {}
+}
+        "#,
+            r#"
+trait Bar {
+    fn a() {}
+    fn c() {}
+    fn b() {}
+    fn d() {}
+}
+struct Foo;
+impl Bar for Foo {
+    fn a() {}
+    fn c() {}
+    fn b() {}
+    fn d() {}
+}
+        "#,
+        )
+    }
+}
diff --git a/crates/assists/src/lib.rs b/crates/assists/src/lib.rs
index 90009c55a..1080294ab 100644
--- a/crates/assists/src/lib.rs
+++ b/crates/assists/src/lib.rs
@@ -146,6 +146,7 @@ mod handlers {
    mod remove_mut;
    mod remove_unused_param;
    mod reorder_fields;
+    mod reorder_impl;
    mod replace_derive_with_manual_impl;
    mod replace_if_let_with_match;
    mod replace_impl_trait_with_generic;
@@ -202,6 +203,7 @@ mod handlers {
            remove_mut::remove_mut,
            remove_unused_param::remove_unused_param,
            reorder_fields::reorder_fields,
+            reorder_impl::reorder_impl,
            replace_derive_with_manual_impl::replace_derive_with_manual_impl,
            replace_if_let_with_match::replace_if_let_with_match,
            replace_if_let_with_match::replace_match_with_if_let,
diff --git a/crates/assists/src/tests/generated.rs b/crates/assists/src/tests/generated.rs
index e28837b53..217f577eb 100644
--- a/crates/assists/src/tests/generated.rs
+++ b/crates/assists/src/tests/generated.rs
@@ -896,6 +896,41 @@ const test: Foo = Foo {foo: 1, bar: 0}
 }
 #[test]
+fn doctest_reorder_impl() {
+    check_doc_test(
+        "reorder_impl",
+        r#####"
+trait Foo {
+    fn a() {}
+    fn b() {}
+    fn c() {}
+}
+struct Bar;
+$0impl Foo for Bar {
+    fn b() {}
+    fn c() {}
+    fn a() {}
+}
+"#####,
+        r#####"
+trait Foo {
+    fn a() {}
+    fn b() {}
+    fn c() {}
+}
+struct Bar;
+impl Foo for Bar {
+    fn a() {}
+    fn b() {}
+    fn c() {}
+}
+"#####,
+    )
+}
+#[test]
 fn doctest_replace_derive_with_manual_impl() {
    check_doc_test(
        "replace_derive_with_manual_impl",
diff --git a/crates/completion/src/completions/attribute.rs b/crates/completion/src/completions/attribute.rs
index 3a29b5203..e5522980d 100644
--- a/crates/completion/src/completions/attribute.rs
+++ b/crates/completion/src/completions/attribute.rs
@@ -5,7 +5,7 @@
 use itertools::Itertools;
 use rustc_hash::FxHashSet;
-use syntax::{ast, AstNode, SyntaxKind};
+use syntax::{ast, AstNode, T};
 use crate::{
    context::CompletionContext,
@@ -21,15 +21,17 @@ pub(crate) fn complete_attribute(acc: &mut Completions, ctx: &CompletionContext)
    let attribute = ctx.attribute_under_caret.as_ref()?;
    match (attribute.path(), attribute.token_tree()) {
-        (Some(path), Some(token_tree)) => match path.to_string().as_str() {
+        (Some(path), Some(token_tree)) => {
-            "derive" => complete_derive(acc, ctx, token_tree),
+            let path = path.syntax().text();
-            "feature" => complete_lint(acc, ctx, token_tree, FEATURES),
+            if path == "derive" {
-            "allow" | "warn" | "deny" | "forbid" => {
+                complete_derive(acc, ctx, token_tree)
+            } else if path == "feature" {
+                complete_lint(acc, ctx, token_tree, FEATURES)
+            } else if path == "allow" || path == "warn" || path == "deny" || path == "forbid" {
                complete_lint(acc, ctx, token_tree.clone(), DEFAULT_LINT_COMPLETIONS);
                complete_lint(acc, ctx, token_tree, CLIPPY_LINTS);
            }
-            _ => {}
+        }
-        },
        (_, Some(_token_tree)) => {}
        _ => complete_attribute_start(acc, ctx, attribute),
    }
@@ -203,8 +205,7 @@ fn complete_lint(
 fn parse_comma_sep_input(derive_input: ast::TokenTree) -> Result<FxHashSet<String>, ()> {
    match (derive_input.left_delimiter_token(), derive_input.right_delimiter_token()) {
        (Some(left_paren), Some(right_paren))
-            if left_paren.kind() == SyntaxKind::L_PAREN
+            if left_paren.kind() == T!['('] && right_paren.kind() == T![')'] =>
-                && right_paren.kind() == SyntaxKind::R_PAREN =>
        {
            let mut input_derives = FxHashSet::default();
            let mut current_derive = String::new();
@@ -216,7 +217,7 @@ fn parse_comma_sep_input(derive_input: ast::TokenTree) -> Result<FxHashSet<Strin
                .skip(1)
                .take_while(|token| token != &right_paren)
            {
-                if SyntaxKind::COMMA == token.kind() {
+                if T![,] == token.kind() {
                    if !current_derive.is_empty() {
                        input_derives.insert(current_derive);
                        current_derive = String::new();
diff --git a/crates/completion/src/completions/dot.rs b/crates/completion/src/completions/dot.rs
index 2e25c8ba2..d04eef65a 100644
--- a/crates/completion/src/completions/dot.rs
+++ b/crates/completion/src/completions/dot.rs
@@ -373,20 +373,20 @@ fn foo(a: A) {
    fn macro_expansion_resilient() {
        check(
            r#"
-macro_rules! dbg {
+macro_rules! d {
    () => {};
    ($val:expr) => {
        match $val { tmp => { tmp } }
    };
    // Trailing comma with single argument is ignored
-    ($val:expr,) => { $crate::dbg!($val) };
+    ($val:expr,) => { $crate::d!($val) };
    ($($val:expr),+ $(,)?) => {
-        ($($crate::dbg!($val)),+,)
+        ($($crate::d!($val)),+,)
    };
 }
 struct A { the_field: u32 }
 fn foo(a: A) {
-    dbg!(a.$0)
+    d!(a.$0)
 }
 "#,
            expect![[r#"
diff --git a/crates/completion/src/completions/postfix.rs b/crates/completion/src/completions/postfix.rs
index 87f0c0b2a..9c34ed0b6 100644
--- a/crates/completion/src/completions/postfix.rs
+++ b/crates/completion/src/completions/postfix.rs
@@ -35,11 +35,14 @@ pub(crate) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
        None => return,
    };
+    let ref_removed_ty =
+        std::iter::successors(Some(receiver_ty.clone()), |ty| ty.remove_ref()).last().unwrap();
    let cap = match ctx.config.snippet_cap {
        Some(it) => it,
        None => return,
    };
-    let try_enum = TryEnum::from_ty(&ctx.sema, &receiver_ty);
+    let try_enum = TryEnum::from_ty(&ctx.sema, &ref_removed_ty);
    if let Some(try_enum) = &try_enum {
        match try_enum {
            TryEnum::Result => {
@@ -496,6 +499,27 @@ fn main() {
    fn postfix_completion_for_references() {
        check_edit("dbg", r#"fn main() { &&42.$0 }"#, r#"fn main() { dbg!(&&42) }"#);
        check_edit("refm", r#"fn main() { &&42.$0 }"#, r#"fn main() { &&&mut 42 }"#);
+        check_edit(
+            "ifl",
+            r#"
+enum Option<T> { Some(T), None }
+fn main() {
+    let bar = &Option::Some(true);
+    bar.$0
+}
+"#,
+            r#"
+enum Option<T> { Some(T), None }
+fn main() {
+    let bar = &Option::Some(true);
+    if let Some($1) = bar {
+    $0
+}
+}
+"#,
+        )
    }
    #[test]
diff --git a/crates/completion/src/completions/trait_impl.rs b/crates/completion/src/completions/trait_impl.rs
index aa9c845da..135ae49dc 100644
--- a/crates/completion/src/completions/trait_impl.rs
+++ b/crates/completion/src/completions/trait_impl.rs
@@ -93,11 +93,11 @@ fn completion_match(ctx: &CompletionContext) -> Option<(ImplCompletionKind, Synt
        // `impl .. { const $0 }`
        // ERROR      0
        //   CONST_KW <- *
-        SyntaxKind::CONST_KW => 0,
+        T![const] => 0,
        // `impl .. { fn/type $0 }`
        // FN/TYPE_ALIAS  0
        //   FN_KW        <- *
-        SyntaxKind::FN_KW | SyntaxKind::TYPE_KW => 0,
+        T![fn] | T![type] => 0,
        // `impl .. { fn/type/const foo$0 }`
        // FN/TYPE_ALIAS/CONST  1
        //  NAME                0
@@ -121,7 +121,7 @@ fn completion_match(ctx: &CompletionContext) -> Option<(ImplCompletionKind, Synt
    let impl_def = ast::Impl::cast(impl_item.parent()?.parent()?)?;
    let kind = match impl_item.kind() {
        // `impl ... { const $0 fn/type/const }`
-        _ if token.kind() == SyntaxKind::CONST_KW => ImplCompletionKind::Const,
+        _ if token.kind() == T![const] => ImplCompletionKind::Const,
        SyntaxKind::CONST | SyntaxKind::ERROR => ImplCompletionKind::Const,
        SyntaxKind::TYPE_ALIAS => ImplCompletionKind::TypeAlias,
        SyntaxKind::FN => ImplCompletionKind::Fn,
diff --git a/crates/completion/src/patterns.rs b/crates/completion/src/patterns.rs
index f148b9402..f3ce91dd1 100644
--- a/crates/completion/src/patterns.rs
+++ b/crates/completion/src/patterns.rs
@@ -5,7 +5,7 @@ use syntax::{
    ast::{self, LoopBodyOwner},
    match_ast, AstNode, Direction, NodeOrToken, SyntaxElement,
    SyntaxKind::*,
-    SyntaxNode, SyntaxToken,
+    SyntaxNode, SyntaxToken, T,
 };
 #[cfg(test)]
@@ -119,7 +119,7 @@ pub(crate) fn unsafe_is_prev(element: SyntaxElement) -> bool {
    element
        .into_token()
        .and_then(|it| previous_non_trivia_token(it))
-        .filter(|it| it.kind() == UNSAFE_KW)
+        .filter(|it| it.kind() == T![unsafe])
        .is_some()
 }
 #[test]
@@ -131,7 +131,7 @@ pub(crate) fn if_is_prev(element: SyntaxElement) -> bool {
    element
        .into_token()
        .and_then(|it| previous_non_trivia_token(it))
-        .filter(|it| it.kind() == IF_KW)
+        .filter(|it| it.kind() == T![if])
        .is_some()
 }
@@ -139,7 +139,7 @@ pub(crate) fn fn_is_prev(element: SyntaxElement) -> bool {
    element
        .into_token()
        .and_then(|it| previous_non_trivia_token(it))
-        .filter(|it| it.kind() == FN_KW)
+        .filter(|it| it.kind() == T![fn])
        .is_some()
 }
 #[test]
@@ -154,7 +154,7 @@ pub(crate) fn for_is_prev2(element: SyntaxElement) -> bool {
        .into_token()
        .and_then(|it| previous_non_trivia_token(it))
        .and_then(|it| previous_non_trivia_token(it))
-        .filter(|it| it.kind() == FOR_KW)
+        .filter(|it| it.kind() == T![for])
        .is_some()
 }
 #[test]
diff --git a/crates/flycheck/Cargo.toml b/crates/flycheck/Cargo.toml
index 1bad64a1b..1d19c7886 100644
--- a/crates/flycheck/Cargo.toml
+++ b/crates/flycheck/Cargo.toml
@@ -12,7 +12,7 @@ doctest = false
 [dependencies]
 crossbeam-channel = "0.5.0"
 log = "0.4.8"
-cargo_metadata = "=0.12.0"
+cargo_metadata = "0.12.2"
 serde_json = "1.0.48"
 jod-thread = "0.1.1"
diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index cc1938333..6cbf5cecf 100644
--- a/crates/hir/src/code_model.rs
+++ b/crates/hir/src/code_model.rs
@@ -1263,6 +1263,24 @@ pub enum GenericParam {
 }
 impl_from!(TypeParam, LifetimeParam, ConstParam for GenericParam);
+impl GenericParam {
+    pub fn module(self, db: &dyn HirDatabase) -> Module {
+        match self {
+            GenericParam::TypeParam(it) => it.module(db),
+            GenericParam::LifetimeParam(it) => it.module(db),
+            GenericParam::ConstParam(it) => it.module(db),
+        }
+    }
+    pub fn name(self, db: &dyn HirDatabase) -> Name {
+        match self {
+            GenericParam::TypeParam(it) => it.name(db),
+            GenericParam::LifetimeParam(it) => it.name(db),
+            GenericParam::ConstParam(it) => it.name(db),
+        }
+    }
+}
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub struct TypeParam {
    pub(crate) id: TypeParamId,
diff --git a/crates/hir/src/from_id.rs b/crates/hir/src/from_id.rs
index 3e47a5e9d..c8c5fecd7 100644
--- a/crates/hir/src/from_id.rs
+++ b/crates/hir/src/from_id.rs
@@ -1,6 +1,6 @@
 //! Utility module for converting between hir_def ids and code_model wrappers.
 //!
-//! It's unclear if we need this long-term, but it's definitelly useful while we
+//! It's unclear if we need this long-term, but it's definitely useful while we
 //! are splitting the hir.
 use hir_def::{
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index 6be1eaade..3dc33f248 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -581,7 +581,7 @@ impl ExprCollector<'_> {
        match res.value {
            Some((mark, expansion)) => {
                // FIXME: Statements are too complicated to recover from error for now.
-                // It is because we don't have any hygenine for local variable expansion right now.
+                // It is because we don't have any hygiene for local variable expansion right now.
                if T::can_cast(syntax::SyntaxKind::MACRO_STMTS) && res.err.is_some() {
                    self.expander.exit(self.db, mark);
                    collector(self, None);
@@ -959,7 +959,7 @@ impl ExprCollector<'_> {
    fn collect_tuple_pat(&mut self, args: AstChildren<ast::Pat>) -> (Vec<PatId>, Option<usize>) {
        // Find the location of the `..`, if there is one. Note that we do not
-        // consider the possiblity of there being multiple `..` here.
+        // consider the possibility of there being multiple `..` here.
        let ellipsis = args.clone().position(|p| matches!(p, ast::Pat::RestPat(_)));
        // We want to skip the `..` pattern here, since we account for it above.
        let args = args
diff --git a/crates/hir_def/src/expr.rs b/crates/hir_def/src/expr.rs
index 6a481769d..76f5721e5 100644
--- a/crates/hir_def/src/expr.rs
+++ b/crates/hir_def/src/expr.rs
@@ -1,6 +1,6 @@
 //! This module describes hir-level representation of expressions.
 //!
-//! This representaion is:
+//! This representation is:
 //!
 //! 1. Identity-based. Each expression has an `id`, so we can distinguish
 //!    between different `1` in `1 + 1`.
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index 77017e4ea..f027fd48d 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -267,7 +267,7 @@ impl DefCollector<'_> {
        // Resolve all indeterminate resolved imports again
        // As some of the macros will expand newly import shadowing partial resolved imports
-        // FIXME: We maybe could skip this, if we handle the Indetermine imports in `resolve_imports`
+        // FIXME: We maybe could skip this, if we handle the indeterminate imports in `resolve_imports`
        // correctly
        let partial_resolved = self.resolved_imports.iter().filter_map(|directive| {
            if let PartialResolvedImport::Indeterminate(_) = directive.status {
@@ -402,7 +402,7 @@ impl DefCollector<'_> {
    /// Define a proc macro
    ///
-    /// A proc macro is similar to normal macro scope, but it would not visiable in legacy textual scoped.
+    /// A proc macro is similar to normal macro scope, but it would not visible in legacy textual scoped.
    /// And unconditionally exported.
    fn define_proc_macro(&mut self, name: Name, macro_: MacroDefId) {
        self.update(
@@ -592,7 +592,7 @@ impl DefCollector<'_> {
                    // XXX: urgh, so this works by accident! Here, we look at
                    // the enum data, and, in theory, this might require us to
                    // look back at the crate_def_map, creating a cycle. For
-                    // example, `enum E { crate::some_macro!(); }`. Luckely, the
+                    // example, `enum E { crate::some_macro!(); }`. Luckily, the
                    // only kind of macro that is allowed inside enum is a
                    // `cfg_macro`, and we don't need to run name resolution for
                    // it, but this is sheer luck!
@@ -655,7 +655,7 @@ impl DefCollector<'_> {
        &mut self,
        module_id: LocalModuleId,
        resolutions: &[(Option<Name>, PerNs)],
-        // All resolutions are imported with this visibility; the visibilies in
+        // All resolutions are imported with this visibility; the visibilities in
        // the `PerNs` values are ignored and overwritten
        vis: Visibility,
        import_type: ImportType,
diff --git a/crates/hir_def/src/per_ns.rs b/crates/hir_def/src/per_ns.rs
index 74665c588..a594afce6 100644
--- a/crates/hir_def/src/per_ns.rs
+++ b/crates/hir_def/src/per_ns.rs
@@ -7,7 +7,7 @@ use hir_expand::MacroDefId;
 use crate::{item_scope::ItemInNs, visibility::Visibility, ModuleDefId};
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub struct PerNs {
    pub types: Option<(ModuleDefId, Visibility)>,
    pub values: Option<(ModuleDefId, Visibility)>,
diff --git a/crates/hir_def/src/resolver.rs b/crates/hir_def/src/resolver.rs
index 129f1dbac..61059c349 100644
--- a/crates/hir_def/src/resolver.rs
+++ b/crates/hir_def/src/resolver.rs
@@ -27,7 +27,7 @@ use crate::{
 #[derive(Debug, Clone, Default)]
 pub struct Resolver {
-    // FIXME: all usages generally call `.rev`, so maybe reverse once in consturciton?
+    // FIXME: all usages generally call `.rev`, so maybe reverse once in construction?
    scopes: Vec<Scope>,
 }
@@ -490,6 +490,7 @@ pub enum ScopeDef {
 impl Scope {
    fn process_names(&self, db: &dyn DefDatabase, f: &mut dyn FnMut(Name, ScopeDef)) {
+        let mut seen = FxHashSet::default();
        match self {
            Scope::ModuleScope(m) => {
                // FIXME: should we provide `self` here?
@@ -503,7 +504,9 @@ impl Scope {
                    f(name.clone(), ScopeDef::PerNs(def));
                });
                m.crate_def_map[m.module_id].scope.legacy_macros().for_each(|(name, macro_)| {
-                    f(name.clone(), ScopeDef::PerNs(PerNs::macros(macro_, Visibility::Public)));
+                    let scope = PerNs::macros(macro_, Visibility::Public);
+                    seen.insert((name.clone(), scope));
+                    f(name.clone(), ScopeDef::PerNs(scope));
                });
                m.crate_def_map.extern_prelude.iter().for_each(|(name, &def)| {
                    f(name.clone(), ScopeDef::PerNs(PerNs::types(def, Visibility::Public)));
@@ -514,7 +517,10 @@ impl Scope {
                if let Some(prelude) = m.crate_def_map.prelude {
                    let prelude_def_map = db.crate_def_map(prelude.krate);
                    prelude_def_map[prelude.local_id].scope.entries().for_each(|(name, def)| {
-                        f(name.clone(), ScopeDef::PerNs(def));
+                        let seen_tuple = (name.clone(), def);
+                        if !seen.contains(&seen_tuple) {
+                            f(seen_tuple.0, ScopeDef::PerNs(def));
+                        }
                    });
                }
            }
diff --git a/crates/hir_def/src/visibility.rs b/crates/hir_def/src/visibility.rs
index e6e0853a3..f3bc9d680 100644
--- a/crates/hir_def/src/visibility.rs
+++ b/crates/hir_def/src/visibility.rs
@@ -85,7 +85,7 @@ impl RawVisibility {
 }
 /// Visibility of an item, with the path resolved.
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum Visibility {
    /// Visibility is restricted to a certain module.
    Module(ModuleId),
diff --git a/crates/hir_expand/src/db.rs b/crates/hir_expand/src/db.rs
index ab2637b8c..c62086390 100644
--- a/crates/hir_expand/src/db.rs
+++ b/crates/hir_expand/src/db.rs
@@ -40,7 +40,7 @@ impl TokenExpander {
            // FIXME switch these to ExpandResult as well
            TokenExpander::BuiltinDerive(it) => it.expand(db, id, tt).into(),
            TokenExpander::ProcMacro(_) => {
-                // We store the result in salsa db to prevent non-determinisc behavior in
+                // We store the result in salsa db to prevent non-deterministic behavior in
                // some proc-macro implementation
                // See #4315 for details
                db.expand_proc_macro(id.into()).into()
diff --git a/crates/hir_ty/src/diagnostics/expr.rs b/crates/hir_ty/src/diagnostics/expr.rs
index a1c484fdf..107417c27 100644
--- a/crates/hir_ty/src/diagnostics/expr.rs
+++ b/crates/hir_ty/src/diagnostics/expr.rs
@@ -379,7 +379,7 @@ pub fn record_literal_missing_fields(
    id: ExprId,
    expr: &Expr,
 ) -> Option<(VariantId, Vec<LocalFieldId>, /*exhaustive*/ bool)> {
-    let (fields, exhausitve) = match expr {
+    let (fields, exhaustive) = match expr {
        Expr::RecordLit { path: _, fields, spread } => (fields, spread.is_none()),
        _ => return None,
    };
@@ -400,7 +400,7 @@ pub fn record_literal_missing_fields(
    if missed_fields.is_empty() {
        return None;
    }
-    Some((variant_def, missed_fields, exhausitve))
+    Some((variant_def, missed_fields, exhaustive))
 }
 pub fn record_pattern_missing_fields(
diff --git a/crates/hir_ty/src/diagnostics/match_check.rs b/crates/hir_ty/src/diagnostics/match_check.rs
index 62c329731..61c47eec8 100644
--- a/crates/hir_ty/src/diagnostics/match_check.rs
+++ b/crates/hir_ty/src/diagnostics/match_check.rs
@@ -14,7 +14,7 @@
 //! The algorithm implemented here is a modified version of the one described in
 //! <http://moscova.inria.fr/~maranget/papers/warn/index.html>.
 //! However, to save future implementors from reading the original paper, we
-//! summarise the algorithm here to hopefully save time and be a little clearer
+//! summarize the algorithm here to hopefully save time and be a little clearer
 //! (without being so rigorous).
 //!
 //! The core of the algorithm revolves about a "usefulness" check. In particular, we
@@ -132,7 +132,7 @@
 //! The algorithm is inductive (on the number of columns: i.e., components of tuple patterns).
 //! That means we're going to check the components from left-to-right, so the algorithm
 //! operates principally on the first component of the matrix and new pattern-stack `p`.
-//! This algorithm is realised in the `is_useful` function.
+//! This algorithm is realized in the `is_useful` function.
 //!
 //! Base case (`n = 0`, i.e., an empty tuple pattern):
 //! - If `P` already contains an empty pattern (i.e., if the number of patterns `m > 0`), then
diff --git a/crates/hir_ty/src/display.rs b/crates/hir_ty/src/display.rs
index e9e949c47..d2f1b4014 100644
--- a/crates/hir_ty/src/display.rs
+++ b/crates/hir_ty/src/display.rs
@@ -1,14 +1,15 @@
 //! FIXME: write short doc here
-use std::fmt;
+use std::{borrow::Cow, fmt};
 use crate::{
    db::HirDatabase, utils::generics, ApplicationTy, CallableDefId, FnSig, GenericPredicate,
-    Lifetime, Obligation, OpaqueTyId, ProjectionTy, Substs, TraitRef, Ty, TypeCtor,
+    Lifetime, Obligation, OpaqueTy, OpaqueTyId, ProjectionTy, Substs, TraitRef, Ty, TypeCtor,
 };
+use arrayvec::ArrayVec;
 use hir_def::{
-    find_path, generics::TypeParamProvenance, item_scope::ItemInNs, AdtId, AssocContainerId,
+    db::DefDatabase, find_path, generics::TypeParamProvenance, item_scope::ItemInNs, AdtId,
-    Lookup, ModuleId,
+    AssocContainerId, HasModule, Lookup, ModuleId, TraitId,
 };
 use hir_expand::name::Name;
@@ -257,25 +258,45 @@ impl HirDisplay for ApplicationTy {
                t.hir_fmt(f)?;
                write!(f, "; _]")?;
            }
-            TypeCtor::RawPtr(m) => {
+            TypeCtor::RawPtr(m) | TypeCtor::Ref(m) => {
                let t = self.parameters.as_single();
+                let ty_display =
+                    t.into_displayable(f.db, f.max_size, f.omit_verbose_types, f.display_target);
-                write!(f, "*{}", m.as_keyword_for_ptr())?;
+                if matches!(self.ctor, TypeCtor::RawPtr(_)) {
-                if matches!(t, Ty::Dyn(predicates) if predicates.len() > 1) {
+                    write!(f, "*{}", m.as_keyword_for_ptr())?;
-                    write!(f, "(")?;
-                    t.hir_fmt(f)?;
-                    write!(f, ")")?;
                } else {
-                    t.hir_fmt(f)?;
+                    write!(f, "&{}", m.as_keyword_for_ref())?;
+                }
+                let datas;
+                let predicates = match t {
+                    Ty::Dyn(predicates) if predicates.len() > 1 => {
+                        Cow::Borrowed(predicates.as_ref())
+                    }
+                    &Ty::Opaque(OpaqueTy {
+                        opaque_ty_id: OpaqueTyId::ReturnTypeImplTrait(func, idx),
+                        ref parameters,
+                    }) => {
+                        datas =
+                            f.db.return_type_impl_traits(func).expect("impl trait id without data");
+                        let data = (*datas)
+                            .as_ref()
+                            .map(|rpit| rpit.impl_traits[idx as usize].bounds.clone());
+                        let bounds = data.subst(parameters);
+                        Cow::Owned(bounds.value)
+                    }
+                    _ => Cow::Borrowed(&[][..]),
+                };
+                if let [GenericPredicate::Implemented(trait_ref), _] = predicates.as_ref() {
+                    let trait_ = trait_ref.trait_;
+                    if fn_traits(f.db.upcast(), trait_).any(|it| it == trait_) {
+                        return write!(f, "{}", ty_display);
+                    }
                }
-            }
-            TypeCtor::Ref(m) => {
-                let t = self.parameters.as_single();
-                let ty_display =
-                    t.into_displayable(f.db, f.max_size, f.omit_verbose_types, f.display_target);
-                write!(f, "&{}", m.as_keyword_for_ref())?;
+                if predicates.len() > 1 {
-                if matches!(t, Ty::Dyn(predicates) if predicates.len() > 1) {
                    write!(f, "(")?;
                    write!(f, "{}", ty_display)?;
                    write!(f, ")")?;
@@ -595,6 +616,17 @@ impl HirDisplay for FnSig {
    }
 }
+fn fn_traits(db: &dyn DefDatabase, trait_: TraitId) -> impl Iterator<Item = TraitId> {
+    let krate = trait_.lookup(db).container.module(db).krate;
+    let fn_traits = [
+        db.lang_item(krate, "fn".into()),
+        db.lang_item(krate, "fn_mut".into()),
+        db.lang_item(krate, "fn_once".into()),
+    ];
+    // FIXME: Replace ArrayVec when into_iter is a thing on arrays
+    ArrayVec::from(fn_traits).into_iter().flatten().flat_map(|it| it.as_trait())
+}
 pub fn write_bounds_like_dyn_trait(
    predicates: &[GenericPredicate],
    f: &mut HirFormatter,
@@ -607,10 +639,15 @@ pub fn write_bounds_like_dyn_trait(
    // predicate for that trait).
    let mut first = true;
    let mut angle_open = false;
+    let mut is_fn_trait = false;
    for p in predicates.iter() {
        match p {
            GenericPredicate::Implemented(trait_ref) => {
-                if angle_open {
+                let trait_ = trait_ref.trait_;
+                if !is_fn_trait {
+                    is_fn_trait = fn_traits(f.db.upcast(), trait_).any(|it| it == trait_);
+                }
+                if !is_fn_trait && angle_open {
                    write!(f, ">")?;
                    angle_open = false;
                }
@@ -620,14 +657,27 @@ pub fn write_bounds_like_dyn_trait(
                // We assume that the self type is $0 (i.e. the
                // existential) here, which is the only thing that's
                // possible in actual Rust, and hence don't print it
-                write!(f, "{}", f.db.trait_data(trait_ref.trait_).name)?;
+                write!(f, "{}", f.db.trait_data(trait_).name)?;
-                if trait_ref.substs.len() > 1 {
+                if let [_, params @ ..] = &*trait_ref.substs.0 {
-                    write!(f, "<")?;
+                    if is_fn_trait {
-                    f.write_joined(&trait_ref.substs[1..], ", ")?;
+                        if let Some(args) = params.first().and_then(|it| it.as_tuple()) {
-                    // there might be assoc type bindings, so we leave the angle brackets open
+                            write!(f, "(")?;
-                    angle_open = true;
+                            f.write_joined(&*args.0, ", ")?;
+                            write!(f, ")")?;
+                        }
+                    } else if !params.is_empty() {
+                        write!(f, "<")?;
+                        f.write_joined(params, ", ")?;
+                        // there might be assoc type bindings, so we leave the angle brackets open
+                        angle_open = true;
+                    }
                }
            }
+            GenericPredicate::Projection(projection_pred) if is_fn_trait => {
+                is_fn_trait = false;
+                write!(f, " -> ")?;
+                projection_pred.ty.hir_fmt(f)?;
+            }
            GenericPredicate::Projection(projection_pred) => {
                // in types in actual Rust, these will always come
                // after the corresponding Implemented predicate
diff --git a/crates/hir_ty/src/lower.rs b/crates/hir_ty/src/lower.rs
index 222f61a11..9594cce8b 100644
--- a/crates/hir_ty/src/lower.rs
+++ b/crates/hir_ty/src/lower.rs
@@ -491,16 +491,16 @@ impl Ty {
    fn from_hir_path_inner(
        ctx: &TyLoweringContext<'_>,
        segment: PathSegment<'_>,
-        typable: TyDefId,
+        typeable: TyDefId,
        infer_args: bool,
    ) -> Ty {
-        let generic_def = match typable {
+        let generic_def = match typeable {
            TyDefId::BuiltinType(_) => None,
            TyDefId::AdtId(it) => Some(it.into()),
            TyDefId::TypeAliasId(it) => Some(it.into()),
        };
        let substs = substs_from_path_segment(ctx, segment, generic_def, infer_args);
-        ctx.db.ty(typable).subst(&substs)
+        ctx.db.ty(typeable).subst(&substs)
    }
    /// Collect generic arguments from a path into a `Substs`. See also
diff --git a/crates/hir_ty/src/tests/display_source_code.rs b/crates/hir_ty/src/tests/display_source_code.rs
index b502135d8..3d29021aa 100644
--- a/crates/hir_ty/src/tests/display_source_code.rs
+++ b/crates/hir_ty/src/tests/display_source_code.rs
@@ -39,3 +39,18 @@ fn main() {
 "#,
    );
 }
+#[test]
+fn render_raw_ptr_impl_ty() {
+    check_types_source_code(
+        r#"
+trait Sized {}
+trait Unpin {}
+fn foo() -> *const (impl Unpin + Sized) { loop {} }
+fn main() {
+    let foo = foo();
+    foo;
+}   //^ *const (impl Unpin + Sized)
+"#,
+    );
+}
diff --git a/crates/hir_ty/src/tests/traits.rs b/crates/hir_ty/src/tests/traits.rs
index 41d097519..e5a3f95a6 100644
--- a/crates/hir_ty/src/tests/traits.rs
+++ b/crates/hir_ty/src/tests/traits.rs
@@ -3038,16 +3038,16 @@ fn infer_box_fn_arg() {
            406..417 '&self.inner': &*mut T
            407..411 'self': &Box<T>
            407..417 'self.inner': *mut T
-            478..575 '{     ...(&s) }': FnOnce::Output<dyn FnOnce<(&Option<i32>,)>, (&Option<i32>,)>
+            478..575 '{     ...(&s) }': FnOnce::Output<dyn FnOnce(&Option<i32>), (&Option<i32>,)>
            488..489 's': Option<i32>
            492..504 'Option::None': Option<i32>
-            514..515 'f': Box<dyn FnOnce<(&Option<i32>,)>>
+            514..515 'f': Box<dyn FnOnce(&Option<i32>)>
            549..562 'box (|ps| {})': Box<|{unknown}| -> ()>
            554..561 '|ps| {}': |{unknown}| -> ()
            555..557 'ps': {unknown}
            559..561 '{}': ()
-            568..569 'f': Box<dyn FnOnce<(&Option<i32>,)>>
+            568..569 'f': Box<dyn FnOnce(&Option<i32>)>
-            568..573 'f(&s)': FnOnce::Output<dyn FnOnce<(&Option<i32>,)>, (&Option<i32>,)>
+            568..573 'f(&s)': FnOnce::Output<dyn FnOnce(&Option<i32>), (&Option<i32>,)>
            570..572 '&s': &Option<i32>
            571..572 's': Option<i32>
        "#]],
diff --git a/crates/ide/src/call_hierarchy.rs b/crates/ide/src/call_hierarchy.rs
index 4d8983cb2..e8999a7f3 100644
--- a/crates/ide/src/call_hierarchy.rs
+++ b/crates/ide/src/call_hierarchy.rs
@@ -5,7 +5,7 @@ use indexmap::IndexMap;
 use hir::Semantics;
 use ide_db::call_info::FnCallNode;
 use ide_db::RootDatabase;
-use syntax::{ast, match_ast, AstNode, TextRange};
+use syntax::{ast, AstNode, TextRange};
 use crate::{
    display::TryToNav, goto_definition, references, FilePosition, NavigationTarget, RangeInfo,
@@ -47,28 +47,23 @@ pub(crate) fn incoming_calls(db: &RootDatabase, position: FilePosition) -> Optio
    let mut calls = CallLocations::default();
-    for reference in refs.info.references() {
+    for (&file_id, references) in refs.info.references().iter() {
-        let file_id = reference.file_range.file_id;
        let file = sema.parse(file_id);
        let file = file.syntax();
-        let token = file.token_at_offset(reference.file_range.range.start()).next()?;
+        for reference in references {
-        let token = sema.descend_into_macros(token);
+            let token = file.token_at_offset(reference.range.start()).next()?;
-        let syntax = token.parent();
+            let token = sema.descend_into_macros(token);
+            let syntax = token.parent();
-        // This target is the containing function
-        if let Some(nav) = syntax.ancestors().find_map(|node| {
+            // This target is the containing function
-            match_ast! {
+            if let Some(nav) = syntax.ancestors().find_map(|node| {
-                match node {
+                let fn_ = ast::Fn::cast(node)?;
-                    ast::Fn(it) => {
+                let def = sema.to_def(&fn_)?;
-                        let def = sema.to_def(&it)?;
+                def.try_to_nav(sema.db)
-                        def.try_to_nav(sema.db)
+            }) {
-                    },
+                let relative_range = reference.range;
-                    _ => None,
+                calls.add(&nav, relative_range);
-                }
            }
-        }) {
-            let relative_range = reference.file_range.range;
-            calls.add(&nav, relative_range);
        }
    }
@@ -91,17 +86,12 @@ pub(crate) fn outgoing_calls(db: &RootDatabase, position: FilePosition) -> Optio
        .filter_map(|node| FnCallNode::with_node_exact(&node))
        .filter_map(|call_node| {
            let name_ref = call_node.name_ref()?;
+            let func_target = match call_node {
-            if let Some(func_target) = match &call_node {
                FnCallNode::CallExpr(expr) => {
                    //FIXME: Type::as_callable is broken
                    let callable = sema.type_of_expr(&expr.expr()?)?.as_callable(db)?;
                    match callable.kind() {
-                        hir::CallableKind::Function(it) => {
+                        hir::CallableKind::Function(it) => it.try_to_nav(db),
-                            let fn_def: hir::Function = it.into();
-                            let nav = fn_def.try_to_nav(db)?;
-                            Some(nav)
-                        }
                        _ => None,
                    }
                }
@@ -109,11 +99,8 @@ pub(crate) fn outgoing_calls(db: &RootDatabase, position: FilePosition) -> Optio
                    let function = sema.resolve_method_call(&expr)?;
                    function.try_to_nav(db)
                }
-            } {
+            }?;
-                Some((func_target, name_ref.syntax().text_range()))
+            Some((func_target, name_ref.syntax().text_range()))
-            } else {
-                None
-            }
        })
        .for_each(|(nav, range)| calls.add(&nav, range));
diff --git a/crates/ide/src/display/navigation_target.rs b/crates/ide/src/display/navigation_target.rs
index e24c78301..4eecae697 100644
--- a/crates/ide/src/display/navigation_target.rs
+++ b/crates/ide/src/display/navigation_target.rs
@@ -215,10 +215,8 @@ impl TryToNav for Definition {
            Definition::ModuleDef(it) => it.try_to_nav(db),
            Definition::SelfType(it) => it.try_to_nav(db),
            Definition::Local(it) => Some(it.to_nav(db)),
-            Definition::TypeParam(it) => it.try_to_nav(db),
+            Definition::GenericParam(it) => it.try_to_nav(db),
-            Definition::LifetimeParam(it) => it.try_to_nav(db),
            Definition::Label(it) => Some(it.to_nav(db)),
-            Definition::ConstParam(it) => it.try_to_nav(db),
        }
    }
 }
@@ -389,6 +387,16 @@ impl TryToNav for hir::AssocItem {
    }
 }
+impl TryToNav for hir::GenericParam {
+    fn try_to_nav(&self, db: &RootDatabase) -> Option<NavigationTarget> {
+        match self {
+            hir::GenericParam::TypeParam(it) => it.try_to_nav(db),
+            hir::GenericParam::ConstParam(it) => it.try_to_nav(db),
+            hir::GenericParam::LifetimeParam(it) => it.try_to_nav(db),
+        }
+    }
+}
 impl ToNav for hir::Local {
    fn to_nav(&self, db: &RootDatabase) -> NavigationTarget {
        let src = self.source(db);
diff --git a/crates/ide/src/doc_links.rs b/crates/ide/src/doc_links.rs
index 1ff818de2..de10406bc 100644
--- a/crates/ide/src/doc_links.rs
+++ b/crates/ide/src/doc_links.rs
@@ -1,6 +1,6 @@
 //! Resolves and rewrites links in markdown documentation.
-use std::{convert::TryFrom, iter::once};
+use std::{convert::TryFrom, iter::once, ops::Range};
 use itertools::Itertools;
 use pulldown_cmark::{BrokenLink, CowStr, Event, InlineStr, LinkType, Options, Parser, Tag};
@@ -39,7 +39,7 @@ pub(crate) fn rewrite_links(db: &RootDatabase, markdown: &str, definition: &Defi
        if target.contains("://") {
            (target.to_string(), title.to_string())
        } else {
-            // Two posibilities:
+            // Two possibilities:
            // * path-based links: `../../module/struct.MyStruct.html`
            // * module-based links (AKA intra-doc links): `super::super::module::MyStruct`
            if let Some(rewritten) = rewrite_intra_doc_link(db, *definition, target, title) {
@@ -61,6 +61,30 @@ pub(crate) fn rewrite_links(db: &RootDatabase, markdown: &str, definition: &Defi
    out
 }
+pub(crate) fn extract_definitions_from_markdown(
+    markdown: &str,
+) -> Vec<(String, Option<hir::Namespace>, Range<usize>)> {
+    let mut res = vec![];
+    let mut cb = |link: BrokenLink| {
+        Some((
+            /*url*/ link.reference.to_owned().into(),
+            /*title*/ link.reference.to_owned().into(),
+        ))
+    };
+    let doc = Parser::new_with_broken_link_callback(markdown, Options::empty(), Some(&mut cb));
+    for (event, range) in doc.into_offset_iter() {
+        match event {
+            Event::Start(Tag::Link(_link_type, ref target, ref title)) => {
+                let link = if target.is_empty() { title } else { target };
+                let (link, ns) = parse_link(link);
+                res.push((link.to_string(), ns, range));
+            }
+            _ => {}
+        }
+    }
+    res
+}
 /// Remove all links in markdown documentation.
 pub(crate) fn remove_links(markdown: &str) -> String {
    let mut drop_link = false;
@@ -192,9 +216,7 @@ fn rewrite_intra_doc_link(
        Definition::Field(it) => it.resolve_doc_path(db, link, ns),
        Definition::SelfType(_)
        | Definition::Local(_)
-        | Definition::TypeParam(_)
+        | Definition::GenericParam(_)
-        | Definition::ConstParam(_)
-        | Definition::LifetimeParam(_)
        | Definition::Label(_) => return None,
    }?;
    let krate = resolved.module(db)?.krate();
@@ -420,7 +442,7 @@ fn get_symbol_fragment(db: &dyn HirDatabase, field_or_assoc: &FieldOrAssocItem)
                    function.as_assoc_item(db).map(|assoc| assoc.container(db)),
                    Some(AssocItemContainer::Trait(..))
                );
-                // This distinction may get more complicated when specialisation is available.
+                // This distinction may get more complicated when specialization is available.
                // Rustdoc makes this decision based on whether a method 'has defaultness'.
                // Currently this is only the case for provided trait methods.
                if is_trait_method && !function.has_body(db) {
diff --git a/crates/ide/src/goto_definition.rs b/crates/ide/src/goto_definition.rs
index 95b4cb9e3..cd4afc804 100644
--- a/crates/ide/src/goto_definition.rs
+++ b/crates/ide/src/goto_definition.rs
@@ -1,14 +1,18 @@
 use either::Either;
-use hir::Semantics;
+use hir::{HasAttrs, ModuleDef, Semantics};
 use ide_db::{
    base_db::FileId,
-    defs::{NameClass, NameRefClass},
+    defs::{Definition, NameClass, NameRefClass},
    symbol_index, RootDatabase,
 };
-use syntax::{ast, match_ast, AstNode, SyntaxKind::*, SyntaxToken, TokenAtOffset, T};
+use syntax::{
+    ast, match_ast, AstNode, AstToken, SyntaxKind::*, SyntaxToken, TextSize, TokenAtOffset, T,
+};
 use crate::{
    display::{ToNav, TryToNav},
+    doc_links::extract_definitions_from_markdown,
+    runnables::doc_owner_to_def,
    FilePosition, NavigationTarget, RangeInfo, SymbolKind,
 };
@@ -30,6 +34,10 @@ pub(crate) fn goto_definition(
    let original_token = pick_best(file.token_at_offset(position.offset))?;
    let token = sema.descend_into_macros(original_token.clone());
    let parent = token.parent();
+    if let Some(comment) = ast::Comment::cast(token.clone()) {
+        let nav = def_for_doc_comment(&sema, position, &comment)?.try_to_nav(db)?;
+        return Some(RangeInfo::new(original_token.text_range(), vec![nav]));
+    }
    let nav_targets = match_ast! {
        match parent {
@@ -68,11 +76,58 @@ pub(crate) fn goto_definition(
    Some(RangeInfo::new(original_token.text_range(), nav_targets))
 }
+fn def_for_doc_comment(
+    sema: &Semantics<RootDatabase>,
+    position: FilePosition,
+    doc_comment: &ast::Comment,
+) -> Option<hir::ModuleDef> {
+    let parent = doc_comment.syntax().parent();
+    let (link, ns) = extract_positioned_link_from_comment(position, doc_comment)?;
+    let def = doc_owner_to_def(sema, parent)?;
+    match def {
+        Definition::ModuleDef(def) => match def {
+            ModuleDef::Module(it) => it.resolve_doc_path(sema.db, &link, ns),
+            ModuleDef::Function(it) => it.resolve_doc_path(sema.db, &link, ns),
+            ModuleDef::Adt(it) => it.resolve_doc_path(sema.db, &link, ns),
+            ModuleDef::Variant(it) => it.resolve_doc_path(sema.db, &link, ns),
+            ModuleDef::Const(it) => it.resolve_doc_path(sema.db, &link, ns),
+            ModuleDef::Static(it) => it.resolve_doc_path(sema.db, &link, ns),
+            ModuleDef::Trait(it) => it.resolve_doc_path(sema.db, &link, ns),
+            ModuleDef::TypeAlias(it) => it.resolve_doc_path(sema.db, &link, ns),
+            ModuleDef::BuiltinType(_) => return None,
+        },
+        Definition::Macro(it) => it.resolve_doc_path(sema.db, &link, ns),
+        Definition::Field(it) => it.resolve_doc_path(sema.db, &link, ns),
+        Definition::SelfType(_)
+        | Definition::Local(_)
+        | Definition::GenericParam(_)
+        | Definition::Label(_) => return None,
+    }
+}
+fn extract_positioned_link_from_comment(
+    position: FilePosition,
+    comment: &ast::Comment,
+) -> Option<(String, Option<hir::Namespace>)> {
+    let comment_range = comment.syntax().text_range();
+    let doc_comment = comment.doc_comment()?;
+    let def_links = extract_definitions_from_markdown(doc_comment);
+    let (def_link, ns, _) = def_links.iter().min_by_key(|(_, _, def_link_range)| {
+        let matched_position = comment_range.start() + TextSize::from(def_link_range.start as u32);
+        match position.offset.checked_sub(matched_position) {
+            Some(distance) => distance,
+            None => comment_range.end(),
+        }
+    })?;
+    Some((def_link.to_string(), ns.clone()))
+}
 fn pick_best(tokens: TokenAtOffset<SyntaxToken>) -> Option<SyntaxToken> {
    return tokens.max_by_key(priority);
    fn priority(n: &SyntaxToken) -> usize {
        match n.kind() {
-            IDENT | INT_NUMBER | LIFETIME_IDENT | T![self] => 2,
+            IDENT | INT_NUMBER | LIFETIME_IDENT | T![self] | COMMENT => 2,
            kind if kind.is_trivia() => 0,
            _ => 1,
        }
@@ -1145,4 +1200,34 @@ fn foo<'foo>(_: &'foo ()) {
 }"#,
        )
    }
+    #[test]
+    fn goto_def_for_intra_doc_link_same_file() {
+        check(
+            r#"
+/// Blah, [`bar`](bar) .. [`foo`](foo)$0 has [`bar`](bar)
+pub fn bar() { }
+/// You might want to see [`std::fs::read()`] too.
+pub fn foo() { }
+     //^^^
+}"#,
+        )
+    }
+    #[test]
+    fn goto_def_for_intra_doc_link_inner() {
+        check(
+            r#"
+//- /main.rs
+mod m;
+struct S;
+     //^
+//- /m.rs
+//! [`super::S$0`]
+"#,
+        )
+    }
 }
diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs
index 8cb4a51d8..317b6f011 100644
--- a/crates/ide/src/hover.rs
+++ b/crates/ide/src/hover.rs
@@ -1,6 +1,6 @@
 use hir::{
-    Adt, AsAssocItem, AssocItemContainer, FieldSource, HasAttrs, HasSource, HirDisplay, Module,
+    Adt, AsAssocItem, AssocItemContainer, FieldSource, GenericParam, HasAttrs, HasSource,
-    ModuleDef, ModuleSource, Semantics,
+    HirDisplay, Module, ModuleDef, ModuleSource, Semantics,
 };
 use ide_db::base_db::SourceDatabase;
 use ide_db::{
@@ -17,7 +17,7 @@ use crate::{
    doc_links::{remove_links, rewrite_links},
    markdown_remove::remove_markdown,
    markup::Markup,
-    runnables::{runnable, runnable_fn},
+    runnables::{runnable_fn, runnable_mod},
    FileId, FilePosition, NavigationTarget, RangeInfo, Runnable,
 };
@@ -175,12 +175,7 @@ fn show_implementations_action(db: &RootDatabase, def: Definition) -> Option<Hov
        Definition::SelfType(it) => it.target_ty(db).as_adt(),
        _ => None,
    }?;
-    match adt {
+    adt.try_to_nav(db).map(to_action)
-        Adt::Struct(it) => it.try_to_nav(db),
-        Adt::Union(it) => it.try_to_nav(db),
-        Adt::Enum(it) => it.try_to_nav(db),
-    }
-    .map(to_action)
 }
 fn runnable_action(
@@ -192,7 +187,7 @@ fn runnable_action(
        Definition::ModuleDef(it) => match it {
            ModuleDef::Module(it) => match it.definition_source(sema.db).value {
                ModuleSource::Module(it) => {
-                    runnable(&sema, it.syntax().clone()).map(|it| HoverAction::Runnable(it))
+                    runnable_mod(&sema, it).map(|it| HoverAction::Runnable(it))
                }
                _ => None,
            },
@@ -220,12 +215,12 @@ fn goto_type_action(db: &RootDatabase, def: Definition) -> Option<HoverAction> {
        }
    };
-    if let Definition::TypeParam(it) = def {
+    if let Definition::GenericParam(GenericParam::TypeParam(it)) = def {
        it.trait_bounds(db).into_iter().for_each(|it| push_new_def(it.into()));
    } else {
        let ty = match def {
            Definition::Local(it) => it.ty(db),
-            Definition::ConstParam(it) => it.ty(db),
+            Definition::GenericParam(GenericParam::ConstParam(it)) => it.ty(db),
            _ => return None,
        };
@@ -357,9 +352,11 @@ fn hover_for_definition(db: &RootDatabase, def: Definition) -> Option<Markup> {
            })
        }
        Definition::Label(it) => Some(Markup::fenced_block(&it.name(db))),
-        Definition::LifetimeParam(it) => Some(Markup::fenced_block(&it.name(db))),
+        Definition::GenericParam(it) => match it {
-        Definition::TypeParam(type_param) => Some(Markup::fenced_block(&type_param.display(db))),
+            GenericParam::TypeParam(it) => Some(Markup::fenced_block(&it.display(db))),
-        Definition::ConstParam(it) => from_def_source(db, it, None),
+            GenericParam::LifetimeParam(it) => Some(Markup::fenced_block(&it.name(db))),
+            GenericParam::ConstParam(it) => from_def_source(db, it, None),
+        },
    };
    fn from_def_source<A, D>(db: &RootDatabase, def: D, mod_path: Option<String>) -> Option<Markup>
@@ -1951,16 +1948,16 @@ struct S {
 /// Test cases:
 /// case 1.  bare URL: https://www.example.com/
 /// case 2.  inline URL with title: [example](https://www.example.com/)
-/// case 3.  code refrence: [`Result`]
+/// case 3.  code reference: [`Result`]
-/// case 4.  code refrence but miss footnote: [`String`]
+/// case 4.  code reference but miss footnote: [`String`]
 /// case 5.  autolink: <http://www.example.com/>
 /// case 6.  email address: <[email protected]>
-/// case 7.  refrence: [example][example]
+/// case 7.  reference: [example][example]
 /// case 8.  collapsed link: [example][]
 /// case 9.  shortcut link: [example]
 /// case 10. inline without URL: [example]()
-/// case 11. refrence: [foo][foo]
+/// case 11. reference: [foo][foo]
-/// case 12. refrence: [foo][bar]
+/// case 12. reference: [foo][bar]
 /// case 13. collapsed link: [foo][]
 /// case 14. shortcut link: [foo]
 /// case 15. inline without URL: [foo]()
@@ -1987,16 +1984,16 @@ pub fn fo$0o() {}
                Test cases:
                case 1.  bare URL: https://www.example.com/
                case 2.  inline URL with title: [example](https://www.example.com/)
-                case 3.  code refrence: `Result`
+                case 3.  code reference: `Result`
-                case 4.  code refrence but miss footnote: `String`
+                case 4.  code reference but miss footnote: `String`
                case 5.  autolink: http://www.example.com/
                case 6.  email address: [email protected]
-                case 7.  refrence: example
+                case 7.  reference: example
                case 8.  collapsed link: example
                case 9.  shortcut link: example
                case 10. inline without URL: example
-                case 11. refrence: foo
+                case 11. reference: foo
-                case 12. refrence: foo
+                case 12. reference: foo
                case 13. collapsed link: foo
                case 14. shortcut link: foo
                case 15. inline without URL: foo
diff --git a/crates/ide/src/inlay_hints.rs b/crates/ide/src/inlay_hints.rs
index fe60abfc8..a2039fcc7 100644
--- a/crates/ide/src/inlay_hints.rs
+++ b/crates/ide/src/inlay_hints.rs
@@ -353,9 +353,25 @@ fn is_argument_similar_to_param_name(
    }
    match get_string_representation(argument) {
        None => false,
-        Some(repr) => {
+        Some(argument_string) => {
-            let argument_string = repr.trim_start_matches('_');
+            let num_leading_underscores =
-            argument_string.starts_with(param_name) || argument_string.ends_with(param_name)
+                argument_string.bytes().take_while(|&c| c == b'_').count();
+            // Does the argument name begin with the parameter name? Ignore leading underscores.
+            let mut arg_bytes = argument_string.bytes().skip(num_leading_underscores);
+            let starts_with_pattern = param_name.bytes().all(
+                |expected| matches!(arg_bytes.next(), Some(actual) if expected.eq_ignore_ascii_case(&actual)),
+            );
+            if starts_with_pattern {
+                return true;
+            }
+            // Does the argument name end with the parameter name?
+            let mut arg_bytes = argument_string.bytes().skip(num_leading_underscores);
+            param_name.bytes().rev().all(
+                |expected| matches!(arg_bytes.next_back(), Some(actual) if expected.eq_ignore_ascii_case(&actual)),
+            )
        }
    }
 }
@@ -901,6 +917,9 @@ fn main() {
    twiddle(true);
    doo(true);
+    const TWIDDLE_UPPERCASE: bool = true;
+    twiddle(TWIDDLE_UPPERCASE);
    let mut param_begin: Param = Param {};
    different_order(&param_begin);
    different_order(&mut param_begin);
@@ -1382,4 +1401,41 @@ fn main() {
 "#,
        )
    }
+    #[test]
+    fn fn_hints() {
+        check(
+            r#"
+trait Sized {}
+fn foo() -> impl Fn() { loop {} }
+fn foo1() -> impl Fn(f64) { loop {} }
+fn foo2() -> impl Fn(f64, f64) { loop {} }
+fn foo3() -> impl Fn(f64, f64) -> u32 { loop {} }
+fn foo4() -> &'static dyn Fn(f64, f64) -> u32 { loop {} }
+fn foo5() -> &'static dyn Fn(&'static dyn Fn(f64, f64) -> u32, f64) -> u32 { loop {} }
+fn foo6() -> impl Fn(f64, f64) -> u32 + Sized { loop {} }
+fn foo7() -> *const (impl Fn(f64, f64) -> u32 + Sized) { loop {} }
+fn main() {
+    let foo = foo();
+     // ^^^ impl Fn()
+    let foo = foo1();
+     // ^^^ impl Fn(f64)
+    let foo = foo2();
+     // ^^^ impl Fn(f64, f64)
+    let foo = foo3();
+     // ^^^ impl Fn(f64, f64) -> u32
+    let foo = foo4();
+     // ^^^ &dyn Fn(f64, f64) -> u32
+    let foo = foo5();
+     // ^^^ &dyn Fn(&dyn Fn(f64, f64) -> u32, f64) -> u32
+    let foo = foo6();
+     // ^^^ impl Fn(f64, f64) -> u32 + Sized
+    let foo = foo7();
+     // ^^^ *const (impl Fn(f64, f64) -> u32 + Sized)
+}
+"#,
+        )
+    }
 }
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index cea2a13c8..1e03832ec 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -76,8 +76,8 @@ pub use crate::{
    references::{rename::RenameError, Declaration, ReferenceSearchResult},
    runnables::{Runnable, RunnableKind, TestId},
    syntax_highlighting::{
-        tags::{Highlight, HighlightModifier, HighlightModifiers, HighlightTag},
+        tags::{Highlight, HlMod, HlMods, HlPunct, HlTag},
-        HighlightedRange,
+        HlRange,
    },
 };
 pub use assists::{Assist, AssistConfig, AssistId, AssistKind, InsertUseConfig};
@@ -92,7 +92,7 @@ pub use ide_db::base_db::{
 };
 pub use ide_db::{
    call_info::CallInfo,
-    search::{Reference, ReferenceAccess, ReferenceKind},
+    search::{FileReference, ReferenceAccess, ReferenceKind},
 };
 pub use ide_db::{
    label::Label,
@@ -449,12 +449,12 @@ impl Analysis {
    }
    /// Computes syntax highlighting for the given file
-    pub fn highlight(&self, file_id: FileId) -> Cancelable<Vec<HighlightedRange>> {
+    pub fn highlight(&self, file_id: FileId) -> Cancelable<Vec<HlRange>> {
        self.with_db(|db| syntax_highlighting::highlight(db, file_id, None, false))
    }
    /// Computes syntax highlighting for the given file range.
-    pub fn highlight_range(&self, frange: FileRange) -> Cancelable<Vec<HighlightedRange>> {
+    pub fn highlight_range(&self, frange: FileRange) -> Cancelable<Vec<HlRange>> {
        self.with_db(|db| {
            syntax_highlighting::highlight(db, frange.file_id, Some(frange.range), false)
        })
diff --git a/crates/ide/src/references.rs b/crates/ide/src/references.rs
index c95ed669c..7d4757e02 100644
--- a/crates/ide/src/references.rs
+++ b/crates/ide/src/references.rs
@@ -3,7 +3,7 @@
 //! or `ast::NameRef`. If it's a `ast::NameRef`, at the classification step we
 //! try to resolve the direct tree parent of this element, otherwise we
 //! already have a definition and just need to get its HIR together with
-//! some information that is needed for futher steps of searching.
+//! some information that is needed for further steps of searching.
 //! After that, we collect files that might contain references and look
 //! for text occurrences of the identifier. If there's an `ast::NameRef`
 //! at the index that the match starts at and its tree parent is
@@ -13,15 +13,15 @@ pub(crate) mod rename;
 use hir::Semantics;
 use ide_db::{
+    base_db::FileId,
    defs::{Definition, NameClass, NameRefClass},
-    search::Reference,
+    search::{FileReference, ReferenceAccess, ReferenceKind, SearchScope, UsageSearchResult},
-    search::{ReferenceAccess, ReferenceKind, SearchScope},
    RootDatabase,
 };
 use syntax::{
    algo::find_node_at_offset,
    ast::{self, NameOwner},
-    match_ast, AstNode, SyntaxKind, SyntaxNode, TextRange, TokenAtOffset,
+    match_ast, AstNode, SyntaxNode, TextRange, TokenAtOffset, T,
 };
 use crate::{display::TryToNav, FilePosition, FileRange, NavigationTarget, RangeInfo, SymbolKind};
@@ -29,7 +29,7 @@ use crate::{display::TryToNav, FilePosition, FileRange, NavigationTarget, RangeI
 #[derive(Debug, Clone)]
 pub struct ReferenceSearchResult {
    declaration: Declaration,
-    references: Vec<Reference>,
+    references: UsageSearchResult,
 }
 #[derive(Debug, Clone)]
@@ -48,10 +48,21 @@ impl ReferenceSearchResult {
        &self.declaration.nav
    }
-    pub fn references(&self) -> &[Reference] {
+    pub fn references(&self) -> &UsageSearchResult {
        &self.references
    }
+    pub fn references_with_declaration(mut self) -> UsageSearchResult {
+        let decl_ref = FileReference {
+            range: self.declaration.nav.focus_or_full_range(),
+            kind: self.declaration.kind,
+            access: self.declaration.access,
+        };
+        let file_id = self.declaration.nav.file_id;
+        self.references.references.entry(file_id).or_default().push(decl_ref);
+        self.references
+    }
    /// Total number of references
    /// At least 1 since all valid references should
    /// Have a declaration
@@ -63,21 +74,11 @@ impl ReferenceSearchResult {
 // allow turning ReferenceSearchResult into an iterator
 // over References
 impl IntoIterator for ReferenceSearchResult {
-    type Item = Reference;
+    type Item = (FileId, Vec<FileReference>);
-    type IntoIter = std::vec::IntoIter<Reference>;
+    type IntoIter = std::collections::hash_map::IntoIter<FileId, Vec<FileReference>>;
-    fn into_iter(mut self) -> Self::IntoIter {
+    fn into_iter(self) -> Self::IntoIter {
-        let mut v = Vec::with_capacity(self.len());
+        self.references_with_declaration().into_iter()
-        v.push(Reference {
-            file_range: FileRange {
-                file_id: self.declaration.nav.file_id,
-                range: self.declaration.nav.focus_or_full_range(),
-            },
-            kind: self.declaration.kind,
-            access: self.declaration.access,
-        });
-        v.append(&mut self.references);
-        v.into_iter()
    }
 }
@@ -109,13 +110,12 @@ pub(crate) fn find_all_refs(
    let RangeInfo { range, info: def } = find_name(&sema, &syntax, position, opt_name)?;
-    let references = def
+    let mut usages = def.usages(sema).set_scope(search_scope).all();
-        .usages(sema)
+    usages
-        .set_scope(search_scope)
+        .references
-        .all()
+        .values_mut()
-        .into_iter()
+        .for_each(|it| it.retain(|r| search_kind == ReferenceKind::Other || search_kind == r.kind));
-        .filter(|r| search_kind == ReferenceKind::Other || search_kind == r.kind)
+    usages.references.retain(|_, it| !it.is_empty());
-        .collect();
    let nav = def.try_to_nav(sema.db)?;
    let decl_range = nav.focus_or_full_range();
@@ -130,13 +130,16 @@ pub(crate) fn find_all_refs(
                kind = ReferenceKind::FieldShorthandForLocal;
            }
        }
-    } else if matches!(def, Definition::LifetimeParam(_) | Definition::Label(_)) {
+    } else if matches!(
+        def,
+        Definition::GenericParam(hir::GenericParam::LifetimeParam(_)) | Definition::Label(_)
+    ) {
        kind = ReferenceKind::Lifetime;
    };
    let declaration = Declaration { nav, kind, access: decl_access(&def, &syntax, decl_range) };
-    Some(RangeInfo::new(range, ReferenceSearchResult { declaration, references }))
+    Some(RangeInfo::new(range, ReferenceSearchResult { declaration, references: usages }))
 }
 fn find_name(
@@ -200,7 +203,7 @@ fn get_struct_def_name_for_struct_literal_search(
    position: FilePosition,
 ) -> Option<ast::Name> {
    if let TokenAtOffset::Between(ref left, ref right) = syntax.token_at_offset(position.offset) {
-        if right.kind() != SyntaxKind::L_CURLY && right.kind() != SyntaxKind::L_PAREN {
+        if right.kind() != T!['{'] && right.kind() != T!['('] {
            return None;
        }
        if let Some(name) =
@@ -227,7 +230,7 @@ fn get_enum_def_name_for_struct_literal_search(
    position: FilePosition,
 ) -> Option<ast::Name> {
    if let TokenAtOffset::Between(ref left, ref right) = syntax.token_at_offset(position.offset) {
-        if right.kind() != SyntaxKind::L_CURLY && right.kind() != SyntaxKind::L_PAREN {
+        if right.kind() != T!['{'] && right.kind() != T!['('] {
            return None;
        }
        if let Some(name) =
@@ -252,8 +255,8 @@ fn try_find_self_references(
    syntax: &SyntaxNode,
    position: FilePosition,
 ) -> Option<RangeInfo<ReferenceSearchResult>> {
-    let self_token =
+    let FilePosition { file_id, offset } = position;
-        syntax.token_at_offset(position.offset).find(|t| t.kind() == SyntaxKind::SELF_KW)?;
+    let self_token = syntax.token_at_offset(offset).find(|t| t.kind() == T![self])?;
    let parent = self_token.parent();
    match_ast! {
        match parent {
@@ -274,7 +277,7 @@ fn try_find_self_references(
    let declaration = Declaration {
        nav: NavigationTarget {
-            file_id: position.file_id,
+            file_id,
            full_range: self_param.syntax().text_range(),
            focus_range: Some(param_self_token.text_range()),
            name: param_self_token.text().clone(),
@@ -290,7 +293,7 @@ fn try_find_self_references(
            ReferenceAccess::Read
        }),
    };
-    let references = function
+    let refs = function
        .body()
        .map(|body| {
            body.syntax()
@@ -304,14 +307,16 @@ fn try_find_self_references(
                        None
                    }
                })
-                .map(|token| Reference {
+                .map(|token| FileReference {
-                    file_range: FileRange { file_id: position.file_id, range: token.text_range() },
+                    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();
+    let mut references = UsageSearchResult::default();
+    references.references.insert(file_id, refs);
    Some(RangeInfo::new(
        param_self_token.text_range(),
@@ -1016,12 +1021,14 @@ impl Foo {
            actual += "\n\n";
        }
-        for r in &refs.references {
+        for (file_id, references) in refs.references {
-            format_to!(actual, "{:?} {:?} {:?}", r.file_range.file_id, r.file_range.range, r.kind);
+            for r in references {
-            if let Some(access) = r.access {
+                format_to!(actual, "{:?} {:?} {:?}", file_id, r.range, r.kind);
-                format_to!(actual, " {:?}", access);
+                if let Some(access) = r.access {
+                    format_to!(actual, " {:?}", access);
+                }
+                actual += "\n";
            }
-            actual += "\n";
        }
        expect.assert_eq(&actual)
    }
diff --git a/crates/ide/src/references/rename.rs b/crates/ide/src/references/rename.rs
index 53d79333c..c3ae568c2 100644
--- a/crates/ide/src/references/rename.rs
+++ b/crates/ide/src/references/rename.rs
@@ -1,29 +1,30 @@
 //! FIXME: write short doc here
 use std::{
    convert::TryInto,
-    error::Error,
    fmt::{self, Display},
 };
 use hir::{Module, ModuleDef, ModuleSource, Semantics};
-use ide_db::base_db::{AnchoredPathBuf, FileId, FileRange, SourceDatabaseExt};
 use ide_db::{
+    base_db::{AnchoredPathBuf, FileId, FileRange, SourceDatabaseExt},
    defs::{Definition, NameClass, NameRefClass},
+    search::FileReference,
    RootDatabase,
 };
 use syntax::{
    algo::find_node_at_offset,
    ast::{self, NameOwner},
-    lex_single_syntax_kind, match_ast, AstNode, SyntaxKind, SyntaxNode, SyntaxToken,
+    lex_single_syntax_kind, match_ast, AstNode, SyntaxKind, SyntaxNode, SyntaxToken, T,
 };
 use test_utils::mark;
 use text_edit::TextEdit;
 use crate::{
-    references::find_all_refs, FilePosition, FileSystemEdit, RangeInfo, Reference, ReferenceKind,
+    FilePosition, FileSystemEdit, RangeInfo, ReferenceKind, ReferenceSearchResult, SourceChange,
-    SourceChange, SourceFileEdit, TextRange, TextSize,
+    SourceFileEdit, TextRange, TextSize,
 };
+type RenameResult<T> = Result<T, RenameError>;
 #[derive(Debug)]
 pub struct RenameError(pub(crate) String);
@@ -33,26 +34,30 @@ impl fmt::Display for RenameError {
    }
 }
-impl Error for RenameError {}
+macro_rules! format_err {
+    ($fmt:expr) => {RenameError(format!($fmt))};
+    ($fmt:expr, $($arg:tt)+) => {RenameError(format!($fmt, $($arg)+))}
+}
+macro_rules! bail {
+    ($($tokens:tt)*) => {return Err(format_err!($($tokens)*))}
+}
 pub(crate) fn prepare_rename(
    db: &RootDatabase,
    position: FilePosition,
-) -> Result<RangeInfo<()>, RenameError> {
+) -> RenameResult<RangeInfo<()>> {
    let sema = Semantics::new(db);
    let source_file = sema.parse(position.file_id);
    let syntax = source_file.syntax();
    if let Some(module) = find_module_at_offset(&sema, position, syntax) {
        rename_mod(&sema, position, module, "dummy")
    } else if let Some(self_token) =
-        syntax.token_at_offset(position.offset).find(|t| t.kind() == SyntaxKind::SELF_KW)
+        syntax.token_at_offset(position.offset).find(|t| t.kind() == T![self])
    {
        rename_self_to_param(&sema, position, self_token, "dummy")
    } else {
-        let range = match find_all_refs(&sema, position, None) {
+        let RangeInfo { range, .. } = find_all_refs(&sema, position)?;
-            Some(RangeInfo { range, .. }) => range,
-            None => return Err(RenameError("No references found at position".to_string())),
-        };
        Ok(RangeInfo::new(range, SourceChange::from(vec![])))
    }
    .map(|info| RangeInfo::new(info.range, ()))
@@ -62,7 +67,7 @@ pub(crate) fn rename(
    db: &RootDatabase,
    position: FilePosition,
    new_name: &str,
-) -> Result<RangeInfo<SourceChange>, RenameError> {
+) -> RenameResult<RangeInfo<SourceChange>> {
    let sema = Semantics::new(db);
    rename_with_semantics(&sema, position, new_name)
 }
@@ -71,42 +76,18 @@ pub(crate) fn rename_with_semantics(
    sema: &Semantics<RootDatabase>,
    position: FilePosition,
    new_name: &str,
-) -> Result<RangeInfo<SourceChange>, RenameError> {
+) -> RenameResult<RangeInfo<SourceChange>> {
-    let is_lifetime_name = match lex_single_syntax_kind(new_name) {
-        Some(res) => match res {
-            (SyntaxKind::IDENT, _) => false,
-            (SyntaxKind::UNDERSCORE, _) => false,
-            (SyntaxKind::SELF_KW, _) => return rename_to_self(&sema, position),
-            (SyntaxKind::LIFETIME_IDENT, _) if new_name != "'static" && new_name != "'_" => true,
-            (SyntaxKind::LIFETIME_IDENT, _) => {
-                return Err(RenameError(format!(
-                    "Invalid name `{0}`: Cannot rename lifetime to {0}",
-                    new_name
-                )))
-            }
-            (_, Some(syntax_error)) => {
-                return Err(RenameError(format!("Invalid name `{}`: {}", new_name, syntax_error)))
-            }
-            (_, None) => {
-                return Err(RenameError(format!("Invalid name `{}`: not an identifier", new_name)))
-            }
-        },
-        None => return Err(RenameError(format!("Invalid name `{}`: not an identifier", new_name))),
-    };
    let source_file = sema.parse(position.file_id);
    let syntax = source_file.syntax();
-    // this is here to prevent lifetime renames from happening on modules and self
-    if is_lifetime_name {
+    if let Some(module) = find_module_at_offset(&sema, position, syntax) {
-        rename_reference(&sema, position, new_name, is_lifetime_name)
-    } else if let Some(module) = find_module_at_offset(&sema, position, syntax) {
        rename_mod(&sema, position, module, new_name)
    } else if let Some(self_token) =
-        syntax.token_at_offset(position.offset).find(|t| t.kind() == SyntaxKind::SELF_KW)
+        syntax.token_at_offset(position.offset).find(|t| t.kind() == T![self])
    {
        rename_self_to_param(&sema, position, self_token, new_name)
    } else {
-        rename_reference(&sema, position, new_name, is_lifetime_name)
+        rename_reference(&sema, position, new_name)
    }
 }
@@ -127,6 +108,33 @@ pub(crate) fn will_rename_file(
    Some(change)
 }
+#[derive(Debug, PartialEq)]
+enum IdentifierKind {
+    Ident,
+    Lifetime,
+    ToSelf,
+    Underscore,
+}
+fn check_identifier(new_name: &str) -> RenameResult<IdentifierKind> {
+    match lex_single_syntax_kind(new_name) {
+        Some(res) => match res {
+            (SyntaxKind::IDENT, _) => Ok(IdentifierKind::Ident),
+            (T![_], _) => Ok(IdentifierKind::Underscore),
+            (T![self], _) => Ok(IdentifierKind::ToSelf),
+            (SyntaxKind::LIFETIME_IDENT, _) if new_name != "'static" && new_name != "'_" => {
+                Ok(IdentifierKind::Lifetime)
+            }
+            (SyntaxKind::LIFETIME_IDENT, _) => {
+                bail!("Invalid name `{0}`: Cannot rename lifetime to {0}", new_name)
+            }
+            (_, Some(syntax_error)) => bail!("Invalid name `{}`: {}", new_name, syntax_error),
+            (_, None) => bail!("Invalid name `{}`: not an identifier", new_name),
+        },
+        None => bail!("Invalid name `{}`: not an identifier", new_name),
+    }
+}
 fn find_module_at_offset(
    sema: &Semantics<RootDatabase>,
    position: FilePosition,
@@ -155,39 +163,54 @@ fn find_module_at_offset(
    Some(module)
 }
-fn source_edit_from_reference(
+fn find_all_refs(
+    sema: &Semantics<RootDatabase>,
+    position: FilePosition,
+) -> RenameResult<RangeInfo<ReferenceSearchResult>> {
+    crate::references::find_all_refs(sema, position, None)
+        .ok_or_else(|| format_err!("No references found at position"))
+}
+fn source_edit_from_references(
    sema: &Semantics<RootDatabase>,
-    reference: Reference,
+    file_id: FileId,
+    references: &[FileReference],
    new_name: &str,
 ) -> SourceFileEdit {
-    let mut replacement_text = String::new();
+    let mut edit = TextEdit::builder();
-    let range = match reference.kind {
+    for reference in references {
-        ReferenceKind::FieldShorthandForField => {
+        let mut replacement_text = String::new();
-            mark::hit!(test_rename_struct_field_for_shorthand);
+        let range = match reference.kind {
-            replacement_text.push_str(new_name);
+            ReferenceKind::FieldShorthandForField => {
-            replacement_text.push_str(": ");
+                mark::hit!(test_rename_struct_field_for_shorthand);
-            TextRange::new(reference.file_range.range.start(), reference.file_range.range.start())
+                replacement_text.push_str(new_name);
-        }
+                replacement_text.push_str(": ");
-        ReferenceKind::FieldShorthandForLocal => {
+                TextRange::new(reference.range.start(), reference.range.start())
-            mark::hit!(test_rename_local_for_field_shorthand);
+            }
-            replacement_text.push_str(": ");
+            ReferenceKind::FieldShorthandForLocal => {
-            replacement_text.push_str(new_name);
+                mark::hit!(test_rename_local_for_field_shorthand);
-            TextRange::new(reference.file_range.range.end(), reference.file_range.range.end())
+                replacement_text.push_str(": ");
-        }
+                replacement_text.push_str(new_name);
-        ReferenceKind::RecordFieldExprOrPat => {
+                TextRange::new(reference.range.end(), reference.range.end())
-            mark::hit!(test_rename_field_expr_pat);
+            }
-            replacement_text.push_str(new_name);
+            ReferenceKind::RecordFieldExprOrPat => {
-            edit_text_range_for_record_field_expr_or_pat(sema, reference.file_range, new_name)
+                mark::hit!(test_rename_field_expr_pat);
-        }
+                replacement_text.push_str(new_name);
-        _ => {
+                edit_text_range_for_record_field_expr_or_pat(
-            replacement_text.push_str(new_name);
+                    sema,
-            reference.file_range.range
+                    FileRange { file_id, range: reference.range },
-        }
+                    new_name,
-    };
+                )
-    SourceFileEdit {
+            }
-        file_id: reference.file_range.file_id,
+            _ => {
-        edit: TextEdit::replace(range, replacement_text),
+                replacement_text.push_str(new_name);
+                reference.range
+            }
+        };
+        edit.replace(range, replacement_text);
    }
+    SourceFileEdit { file_id, edit: edit.finish() }
 }
 fn edit_text_range_for_record_field_expr_or_pat(
@@ -223,7 +246,10 @@ fn rename_mod(
    position: FilePosition,
    module: Module,
    new_name: &str,
-) -> Result<RangeInfo<SourceChange>, RenameError> {
+) -> RenameResult<RangeInfo<SourceChange>> {
+    if IdentifierKind::Ident != check_identifier(new_name)? {
+        bail!("Invalid name `{0}`: cannot rename module to {0}", new_name);
+    }
    let mut source_file_edits = Vec::new();
    let mut file_system_edits = Vec::new();
@@ -254,12 +280,10 @@ fn rename_mod(
        source_file_edits.push(edit);
    }
-    let RangeInfo { range, info: refs } = find_all_refs(sema, position, None)
+    let RangeInfo { range, info: refs } = find_all_refs(sema, position)?;
-        .ok_or_else(|| RenameError("No references found at position".to_string()))?;
+    let ref_edits = refs.references().iter().map(|(&file_id, references)| {
-    let ref_edits = refs
+        source_edit_from_references(sema, file_id, references, new_name)
-        .references
+    });
-        .into_iter()
-        .map(|reference| source_edit_from_reference(sema, reference, new_name));
    source_file_edits.extend(ref_edits);
    Ok(RangeInfo::new(range, SourceChange::from_edits(source_file_edits, file_system_edits)))
@@ -274,27 +298,26 @@ fn rename_to_self(
    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()))?;
+        .ok_or_else(|| format_err!("No surrounding method declaration found"))?;
    let param_range = fn_ast
        .param_list()
        .and_then(|p| p.params().next())
-        .ok_or_else(|| RenameError("Method has no parameters".to_string()))?
+        .ok_or_else(|| format_err!("Method has no parameters"))?
        .syntax()
        .text_range();
    if !param_range.contains(position.offset) {
-        return Err(RenameError("Only the first parameter can be self".to_string()));
+        bail!("Only the first parameter can be self");
    }
    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()))?;
+        .ok_or_else(|| format_err!("No impl block found for function"))?;
    if fn_def.self_param(sema.db).is_some() {
-        return Err(RenameError("Method already has a self parameter".to_string()));
+        bail!("Method already has a self parameter");
    }
    let params = fn_def.assoc_fn_params(sema.db);
-    let first_param =
+    let first_param = params.first().ok_or_else(|| format_err!("Method has no parameters"))?;
-        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() {
@@ -307,23 +330,17 @@ fn rename_to_self(
    };
    if ty != impl_ty {
-        return Err(RenameError("Parameter type differs from impl block type".to_string()));
+        bail!("Parameter type differs from impl block type");
    }
-    let RangeInfo { range, info: refs } = find_all_refs(sema, position, None)
+    let RangeInfo { range, info: refs } = find_all_refs(sema, position)?;
-        .ok_or_else(|| RenameError("No reference found at position".to_string()))?;
-    let (param_ref, usages): (Vec<Reference>, Vec<Reference>) = refs
-        .into_iter()
-        .partition(|reference| param_range.intersect(reference.file_range.range).is_some());
-    if param_ref.is_empty() {
-        return Err(RenameError("Parameter to rename not found".to_string()));
-    }
-    let mut edits = usages
+    let mut edits = refs
-        .into_iter()
+        .references()
-        .map(|reference| source_edit_from_reference(sema, reference, "self"))
+        .iter()
+        .map(|(&file_id, references)| {
+            source_edit_from_references(sema, file_id, references, "self")
+        })
        .collect::<Vec<_>>();
    edits.push(SourceFileEdit {
@@ -367,12 +384,22 @@ fn rename_self_to_param(
    self_token: SyntaxToken,
    new_name: &str,
 ) -> Result<RangeInfo<SourceChange>, RenameError> {
+    let ident_kind = check_identifier(new_name)?;
+    match ident_kind {
+        IdentifierKind::Lifetime => bail!("Invalid name `{}`: not an identifier", new_name),
+        IdentifierKind::ToSelf => {
+            // no-op
+            mark::hit!(rename_self_to_self);
+            return Ok(RangeInfo::new(self_token.text_range(), SourceChange::default()));
+        }
+        _ => (),
+    }
    let source_file = sema.parse(position.file_id);
    let syn = source_file.syntax();
    let text = sema.db.file_text(position.file_id);
    let fn_def = find_node_at_offset::<ast::Fn>(syn, position.offset)
-        .ok_or_else(|| RenameError("No surrounding method declaration found".to_string()))?;
+        .ok_or_else(|| format_err!("No surrounding method declaration found"))?;
    let search_range = fn_def.syntax().text_range();
    let mut edits: Vec<SourceFileEdit> = vec![];
@@ -382,12 +409,10 @@ fn rename_self_to_param(
        if !search_range.contains_inclusive(offset) {
            continue;
        }
-        if let Some(ref usage) =
+        if let Some(ref usage) = syn.token_at_offset(offset).find(|t| t.kind() == T![self]) {
-            syn.token_at_offset(offset).find(|t| t.kind() == SyntaxKind::SELF_KW)
-        {
            let edit = if let Some(ref self_param) = ast::SelfParam::cast(usage.parent()) {
                text_edit_from_self_param(syn, self_param, new_name)
-                    .ok_or_else(|| RenameError("No target type found".to_string()))?
+                    .ok_or_else(|| format_err!("No target type found"))?
            } else {
                TextEdit::replace(usage.text_range(), String::from(new_name))
            };
@@ -395,6 +420,10 @@ fn rename_self_to_param(
        }
    }
+    if edits.len() > 1 && ident_kind == IdentifierKind::Underscore {
+        bail!("Cannot rename reference to `_` as it is being referenced multiple times");
+    }
    let range = ast::SelfParam::cast(self_token.parent())
        .map_or(self_token.text_range(), |p| p.syntax().text_range());
@@ -405,35 +434,43 @@ fn rename_reference(
    sema: &Semantics<RootDatabase>,
    position: FilePosition,
    new_name: &str,
-    is_lifetime_name: bool,
 ) -> Result<RangeInfo<SourceChange>, RenameError> {
-    let RangeInfo { range, info: refs } = match find_all_refs(sema, position, None) {
+    let ident_kind = check_identifier(new_name)?;
-        Some(range_info) => range_info,
+    let RangeInfo { range, info: refs } = find_all_refs(sema, position)?;
-        None => return Err(RenameError("No references found at position".to_string())),
-    };
+    match (ident_kind, &refs.declaration.kind) {
+        (IdentifierKind::ToSelf, ReferenceKind::Lifetime)
-    match (refs.declaration.kind == ReferenceKind::Lifetime, is_lifetime_name) {
+        | (IdentifierKind::Underscore, ReferenceKind::Lifetime)
-        (true, false) => {
+        | (IdentifierKind::Ident, ReferenceKind::Lifetime) => {
-            return Err(RenameError(format!(
+            mark::hit!(rename_not_a_lifetime_ident_ref);
-                "Invalid name `{}`: not a lifetime identifier",
+            bail!("Invalid name `{}`: not a lifetime identifier", new_name)
-                new_name
-            )))
        }
-        (false, true) => {
+        (IdentifierKind::Lifetime, ReferenceKind::Lifetime) => mark::hit!(rename_lifetime),
-            return Err(RenameError(format!("Invalid name `{}`: not an identifier", new_name)))
+        (IdentifierKind::Lifetime, _) => {
+            mark::hit!(rename_not_an_ident_ref);
+            bail!("Invalid name `{}`: not an identifier", new_name)
        }
-        _ => (),
+        (IdentifierKind::ToSelf, ReferenceKind::SelfKw) => {
+            unreachable!("rename_self_to_param should've been called instead")
+        }
+        (IdentifierKind::ToSelf, _) => {
+            mark::hit!(rename_to_self);
+            return rename_to_self(sema, position);
+        }
+        (IdentifierKind::Underscore, _) if !refs.references.is_empty() => {
+            mark::hit!(rename_underscore_multiple);
+            bail!("Cannot rename reference to `_` as it is being referenced multiple times")
+        }
+        (IdentifierKind::Ident, _) | (IdentifierKind::Underscore, _) => mark::hit!(rename_ident),
    }
    let edit = refs
        .into_iter()
-        .map(|reference| source_edit_from_reference(sema, reference, new_name))
+        .map(|(file_id, references)| {
+            source_edit_from_references(sema, file_id, &references, new_name)
+        })
        .collect::<Vec<_>>();
-    if edit.is_empty() {
-        return Err(RenameError("No references found at position".to_string()));
-    }
    Ok(RangeInfo::new(range, SourceChange::from(edit)))
 }
@@ -462,9 +499,11 @@ mod tests {
                        text_edit_builder.replace(indel.delete, indel.insert);
                    }
                }
-                let mut result = analysis.file_text(file_id.unwrap()).unwrap().to_string();
+                if let Some(file_id) = file_id {
-                text_edit_builder.finish().apply(&mut result);
+                    let mut result = analysis.file_text(file_id).unwrap().to_string();
-                assert_eq_text!(ra_fixture_after, &*result);
+                    text_edit_builder.finish().apply(&mut result);
+                    assert_eq_text!(ra_fixture_after, &*result);
+                }
            }
            Err(err) => {
                if ra_fixture_after.starts_with("error:") {
@@ -530,6 +569,7 @@ mod tests {
    #[test]
    fn test_rename_to_invalid_identifier_lifetime() {
+        mark::check!(rename_not_an_ident_ref);
        check(
            "'foo",
            r#"fn main() { let i$0 = 1; }"#,
@@ -539,6 +579,7 @@ mod tests {
    #[test]
    fn test_rename_to_invalid_identifier_lifetime2() {
+        mark::check!(rename_not_a_lifetime_ident_ref);
        check(
            "foo",
            r#"fn main<'a>(_: &'a$0 ()) {}"#,
@@ -547,7 +588,27 @@ mod tests {
    }
    #[test]
+    fn test_rename_to_underscore_invalid() {
+        mark::check!(rename_underscore_multiple);
+        check(
+            "_",
+            r#"fn main(foo$0: ()) {foo;}"#,
+            "error: Cannot rename reference to `_` as it is being referenced multiple times",
+        );
+    }
+    #[test]
+    fn test_rename_mod_invalid() {
+        check(
+            "'foo",
+            r#"mod foo$0 {}"#,
+            "error: Invalid name `'foo`: cannot rename module to 'foo",
+        );
+    }
+    #[test]
    fn test_rename_for_local() {
+        mark::check!(rename_ident);
        check(
            "k",
            r#"
@@ -945,7 +1006,7 @@ use crate::foo$0::FooContent;
 //- /lib.rs
 mod fo$0o;
 //- /foo/mod.rs
-// emtpy
+// empty
 "#,
            expect![[r#"
                RangeInfo {
@@ -995,7 +1056,7 @@ mod fo$0o;
 mod outer { mod fo$0o; }
 //- /outer/foo.rs
-// emtpy
+// empty
 "#,
            expect![[r#"
                RangeInfo {
@@ -1178,6 +1239,7 @@ fn foo(f: foo::Foo) {
    #[test]
    fn test_parameter_to_self() {
+        mark::check!(rename_to_self);
        check(
            "self",
            r#"
@@ -1481,6 +1543,7 @@ fn foo(Foo { i: bar }: foo) -> i32 {
    #[test]
    fn test_rename_lifetimes() {
+        mark::check!(rename_lifetime);
        check(
            "'yeeee",
            r#"
@@ -1565,4 +1628,24 @@ fn foo<'a>() -> &'a () {
 "#,
        )
    }
+    #[test]
+    fn test_self_to_self() {
+        mark::check!(rename_self_to_self);
+        check(
+            "self",
+            r#"
+struct Foo;
+impl Foo {
+    fn foo(self$0) {}
+}
+"#,
+            r#"
+struct Foo;
+impl Foo {
+    fn foo(self) {}
+}
+"#,
+        )
+    }
 }
diff --git a/crates/ide/src/runnables.rs b/crates/ide/src/runnables.rs
index 557563d7e..f5ee7de86 100644
--- a/crates/ide/src/runnables.rs
+++ b/crates/ide/src/runnables.rs
@@ -3,7 +3,7 @@ use std::fmt;
 use assists::utils::test_related_attribute;
 use cfg::CfgExpr;
 use hir::{AsAssocItem, HasAttrs, HasSource, Semantics};
-use ide_db::RootDatabase;
+use ide_db::{defs::Definition, RootDatabase};
 use itertools::Itertools;
 use syntax::{
    ast::{self, AstNode, AttrsOwner, ModuleItemOwner},
@@ -96,21 +96,26 @@ impl Runnable {
 pub(crate) fn runnables(db: &RootDatabase, file_id: FileId) -> Vec<Runnable> {
    let sema = Semantics::new(db);
    let source_file = sema.parse(file_id);
-    source_file.syntax().descendants().filter_map(|i| runnable(&sema, i)).collect()
+    source_file
-}
+        .syntax()
+        .descendants()
-pub(crate) fn runnable(sema: &Semantics<RootDatabase>, item: SyntaxNode) -> Option<Runnable> {
+        .filter_map(|item| {
-    let runnable_item = match_ast! {
+            let runnable = match_ast! {
-        match (item.clone()) {
+                match item {
-            ast::Fn(func) => {
+                    ast::Fn(func) => {
-                let def = sema.to_def(&func)?;
+                        let def = sema.to_def(&func)?;
-                runnable_fn(sema, def)
+                        runnable_fn(&sema, def)
-            },
+                    },
-            ast::Module(it) => runnable_mod(sema, it),
+                    ast::Module(it) => runnable_mod(&sema, it),
-            _ => None,
+                    _ => None,
-        }
+                }
-    };
+            };
-    runnable_item.or_else(|| runnable_doctest(sema, item))
+            runnable.or_else(|| match doc_owner_to_def(&sema, item)? {
+                Definition::ModuleDef(def) => module_def_doctest(&sema, def),
+                _ => None,
+            })
+        })
+        .collect()
 }
 pub(crate) fn runnable_fn(sema: &Semantics<RootDatabase>, def: hir::Function) -> Option<Runnable> {
@@ -145,20 +150,49 @@ pub(crate) fn runnable_fn(sema: &Semantics<RootDatabase>, def: hir::Function) ->
    Some(Runnable { nav, kind, cfg })
 }
-fn runnable_doctest(sema: &Semantics<RootDatabase>, item: SyntaxNode) -> Option<Runnable> {
+pub(crate) fn runnab