23 files changed, 915 insertions, 814 deletions
diff --git a/crates/ra_ide/src/completion.rs b/crates/ra_ide/src/completion.rs
index a721e23c6..e1fcf379d 100644
--- a/crates/ra_ide/src/completion.rs
+++ b/crates/ra_ide/src/completion.rs
@@ -15,6 +15,7 @@ mod complete_unqualified_path;
 mod complete_postfix;
 mod complete_macro_in_item_position;
 mod complete_trait_impl;
+mod patterns;
 #[cfg(test)]
 mod test_utils;
diff --git a/crates/ra_ide/src/completion/complete_keyword.rs b/crates/ra_ide/src/completion/complete_keyword.rs
index fd95bc410..b2f621a11 100644
--- a/crates/ra_ide/src/completion/complete_keyword.rs
+++ b/crates/ra_ide/src/completion/complete_keyword.rs
@@ -1,11 +1,6 @@
 //! FIXME: write short doc here
-use ra_syntax::{
+use ra_syntax::ast;
-    ast::{self, LoopBodyOwner},
-    match_ast, AstNode,
-    SyntaxKind::*,
-    SyntaxToken,
-};
 use crate::completion::{
    CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, Completions,
@@ -41,68 +36,122 @@ pub(super) fn complete_use_tree_keyword(acc: &mut Completions, ctx: &CompletionC
    }
 }
-fn keyword(ctx: &CompletionContext, kw: &str, snippet: &str) -> CompletionItem {
+pub(super) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionContext) {
-    let res = CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), kw)
+    let has_trait_or_impl_parent = ctx.has_impl_parent || ctx.has_trait_parent;
-        .kind(CompletionItemKind::Keyword);
+    if ctx.trait_as_prev_sibling || ctx.impl_as_prev_sibling {
+        add_keyword(ctx, acc, "where", "where ");
-    match ctx.config.snippet_cap {
+        return;
-        Some(cap) => res.insert_snippet(cap, snippet),
-        _ => res.insert_text(if snippet.contains('$') { kw } else { snippet }),
    }
-    .build()
+    if ctx.unsafe_is_prev {
-}
+        if ctx.has_item_list_or_source_file_parent || ctx.block_expr_parent {
+            add_keyword(ctx, acc, "fn", "fn $0() {}")
+        }
+        if (ctx.has_item_list_or_source_file_parent && !has_trait_or_impl_parent)
+            || ctx.block_expr_parent
+        {
+            add_keyword(ctx, acc, "trait", "trait $0 {}");
+            add_keyword(ctx, acc, "impl", "impl $0 {}");
+        }
-pub(super) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionContext) {
-    if !ctx.is_trivial_path {
        return;
    }
+    if ctx.has_item_list_or_source_file_parent || ctx.block_expr_parent {
+        add_keyword(ctx, acc, "fn", "fn $0() {}");
+    }
+    if (ctx.has_item_list_or_source_file_parent && !has_trait_or_impl_parent)
+        || ctx.block_expr_parent
+    {
+        add_keyword(ctx, acc, "use", "use ");
+        add_keyword(ctx, acc, "impl", "impl $0 {}");
+        add_keyword(ctx, acc, "trait", "trait $0 {}");
+    }
-    let fn_def = match &ctx.function_syntax {
+    if ctx.has_item_list_or_source_file_parent && !has_trait_or_impl_parent {
-        Some(it) => it,
+        add_keyword(ctx, acc, "enum", "enum $0 {}");
-        None => return,
+        add_keyword(ctx, acc, "struct", "struct $0 {}");
-    };
+        add_keyword(ctx, acc, "union", "union $0 {}");
-    acc.add(keyword(ctx, "if", "if $0 {}"));
+    }
-    acc.add(keyword(ctx, "match", "match $0 {}"));
-    acc.add(keyword(ctx, "while", "while $0 {}"));
-    acc.add(keyword(ctx, "loop", "loop {$0}"));
+    if ctx.block_expr_parent || ctx.is_match_arm {
+        add_keyword(ctx, acc, "match", "match $0 {}");
+        add_keyword(ctx, acc, "loop", "loop {$0}");
+    }
+    if ctx.block_expr_parent {
+        add_keyword(ctx, acc, "while", "while $0 {}");
+    }
+    if ctx.if_is_prev || ctx.block_expr_parent {
+        add_keyword(ctx, acc, "let", "let ");
+    }
+    if ctx.if_is_prev || ctx.block_expr_parent || ctx.is_match_arm {
+        add_keyword(ctx, acc, "if", "if ");
+        add_keyword(ctx, acc, "if let", "if let ");
+    }
    if ctx.after_if {
-        acc.add(keyword(ctx, "else", "else {$0}"));
+        add_keyword(ctx, acc, "else", "else {$0}");
-        acc.add(keyword(ctx, "else if", "else if $0 {}"));
+        add_keyword(ctx, acc, "else if", "else if $0 {}");
+    }
+    if (ctx.has_item_list_or_source_file_parent && !has_trait_or_impl_parent)
+        || ctx.block_expr_parent
+    {
+        add_keyword(ctx, acc, "mod", "mod $0 {}");
+    }
+    if ctx.bind_pat_parent || ctx.ref_pat_parent {
+        add_keyword(ctx, acc, "mut", "mut ");
    }
-    if is_in_loop_body(&ctx.token) {
+    if ctx.has_item_list_or_source_file_parent || ctx.block_expr_parent {
+        add_keyword(ctx, acc, "const", "const ");
+        add_keyword(ctx, acc, "type", "type ");
+    }
+    if (ctx.has_item_list_or_source_file_parent && !has_trait_or_impl_parent)
+        || ctx.block_expr_parent
+    {
+        add_keyword(ctx, acc, "static", "static ");
+    };
+    if (ctx.has_item_list_or_source_file_parent && !has_trait_or_impl_parent)
+        || ctx.block_expr_parent
+    {
+        add_keyword(ctx, acc, "extern", "extern ");
+    }
+    if ctx.has_item_list_or_source_file_parent || ctx.block_expr_parent || ctx.is_match_arm {
+        add_keyword(ctx, acc, "unsafe", "unsafe ");
+    }
+    if ctx.in_loop_body {
        if ctx.can_be_stmt {
-            acc.add(keyword(ctx, "continue", "continue;"));
+            add_keyword(ctx, acc, "continue", "continue;");
-            acc.add(keyword(ctx, "break", "break;"));
+            add_keyword(ctx, acc, "break", "break;");
        } else {
-            acc.add(keyword(ctx, "continue", "continue"));
+            add_keyword(ctx, acc, "continue", "continue");
-            acc.add(keyword(ctx, "break", "break"));
+            add_keyword(ctx, acc, "break", "break");
        }
    }
+    if ctx.has_item_list_or_source_file_parent && !ctx.has_trait_parent {
+        add_keyword(ctx, acc, "pub", "pub ")
+    }
+    if !ctx.is_trivial_path {
+        return;
+    }
+    let fn_def = match &ctx.function_syntax {
+        Some(it) => it,
+        None => return,
+    };
    acc.add_all(complete_return(ctx, &fn_def, ctx.can_be_stmt));
 }
-fn is_in_loop_body(leaf: &SyntaxToken) -> bool {
+fn keyword(ctx: &CompletionContext, kw: &str, snippet: &str) -> CompletionItem {
-    // FIXME move this to CompletionContext and make it handle macros
+    let res = CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), kw)
-    for node in leaf.parent().ancestors() {
+        .kind(CompletionItemKind::Keyword);
-        if node.kind() == FN_DEF || node.kind() == LAMBDA_EXPR {
-            break;
+    match ctx.config.snippet_cap {
-        }
+        Some(cap) => res.insert_snippet(cap, snippet),
-        let loop_body = match_ast! {
+        _ => res.insert_text(if snippet.contains('$') { kw } else { snippet }),
-            match node {
-                ast::ForExpr(it) => it.loop_body(),
-                ast::WhileExpr(it) => it.loop_body(),
-                ast::LoopExpr(it) => it.loop_body(),
-                _ => None,
-            }
-        };
-        if let Some(body) = loop_body {
-            if body.syntax().text_range().contains_range(leaf.text_range()) {
-                return true;
-            }
-        }
    }
-    false
+    .build()
+}
+fn add_keyword(ctx: &CompletionContext, acc: &mut Completions, kw: &str, snippet: &str) {
+    acc.add(keyword(ctx, kw, snippet));
 }
 fn complete_return(
@@ -121,327 +170,156 @@ fn complete_return(
 #[cfg(test)]
 mod tests {
-    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
+    use crate::completion::{test_utils::completion_list, CompletionKind};
-    use insta::assert_debug_snapshot;
+    use insta::assert_snapshot;
-    fn do_keyword_completion(code: &str) -> Vec<CompletionItem> {
+    fn get_keyword_completions(code: &str) -> String {
-        do_completion(code, CompletionKind::Keyword)
+        completion_list(code, CompletionKind::Keyword)
    }
    #[test]
-    fn completes_keywords_in_use_stmt() {
+    fn test_keywords_in_use_stmt() {
-        assert_debug_snapshot!(
+        assert_snapshot!(
-            do_keyword_completion(
+            get_keyword_completions(r"use <|>"),
-                r"
-                use <|>
-                ",
-            ),
            @r###"
-        [
+            kw crate
-            CompletionItem {
+            kw self
-                label: "crate",
+            kw super
-                source_range: 21..21,
-                delete: 21..21,
-                insert: "crate::",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "self",
-                source_range: 21..21,
-                delete: 21..21,
-                insert: "self",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "super",
-                source_range: 21..21,
-                delete: 21..21,
-                insert: "super::",
-                kind: Keyword,
-            },
-        ]
        "###
        );
-        assert_debug_snapshot!(
+        assert_snapshot!(
-            do_keyword_completion(
+            get_keyword_completions(r"use a::<|>"),
-                r"
-                use a::<|>
-                ",
-            ),
            @r###"
-        [
+            kw self
-            CompletionItem {
+            kw super
-                label: "self",
-                source_range: 24..24,
-                delete: 24..24,
-                insert: "self",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "super",
-                source_range: 24..24,
-                delete: 24..24,
-                insert: "super::",
-                kind: Keyword,
-            },
-        ]
        "###
        );
-        assert_debug_snapshot!(
+        assert_snapshot!(
-            do_keyword_completion(
+            get_keyword_completions(r"use a::{b, <|>}"),
-                r"
-                use a::{b, <|>}
-                ",
-            ),
            @r###"
-        [
+            kw self
-            CompletionItem {
+            kw super
-                label: "self",
-                source_range: 28..28,
-                delete: 28..28,
-                insert: "self",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "super",
-                source_range: 28..28,
-                delete: 28..28,
-                insert: "super::",
-                kind: Keyword,
-            },
-        ]
        "###
        );
    }
    #[test]
-    fn completes_various_keywords_in_function() {
+    fn test_keywords_at_source_file_level() {
-        assert_debug_snapshot!(
+        assert_snapshot!(
-            do_keyword_completion(
+            get_keyword_completions(r"m<|>"),
-                r"
-                fn quux() {
-                    <|>
-                }
-                ",
-            ),
            @r###"
-        [
+            kw const
-            CompletionItem {
+            kw enum
-                label: "if",
+            kw extern
-                source_range: 49..49,
+            kw fn
-                delete: 49..49,
+            kw impl
-                insert: "if $0 {}",
+            kw mod
-                kind: Keyword,
+            kw pub
-            },
+            kw static
-            CompletionItem {
+            kw struct
-                label: "loop",
+            kw trait
-                source_range: 49..49,
+            kw type
-                delete: 49..49,
+            kw union
-                insert: "loop {$0}",
+            kw unsafe
-                kind: Keyword,
+            kw use
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 49..49,
-                delete: 49..49,
-                insert: "match $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "return",
-                source_range: 49..49,
-                delete: 49..49,
-                insert: "return;",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 49..49,
-                delete: 49..49,
-                insert: "while $0 {}",
-                kind: Keyword,
-            },
-        ]
        "###
        );
    }
    #[test]
-    fn completes_else_after_if() {
+    fn test_keywords_in_function() {
-        assert_debug_snapshot!(
+        assert_snapshot!(
-            do_keyword_completion(
+            get_keyword_completions(r"fn quux() { <|> }"),
-                r"
-                fn quux() {
-                    if true {
-                        ()
-                    } <|>
-                }
-                ",
-            ),
            @r###"
-        [
+            kw const
-            CompletionItem {
+            kw extern
-                label: "else",
+            kw fn
-                source_range: 108..108,
+            kw if
-                delete: 108..108,
+            kw if let
-                insert: "else {$0}",
+            kw impl
-                kind: Keyword,
+            kw let
-            },
+            kw loop
-            CompletionItem {
+            kw match
-                label: "else if",
+            kw mod
-                source_range: 108..108,
+            kw return
-                delete: 108..108,
+            kw static
-                insert: "else if $0 {}",
+            kw trait
-                kind: Keyword,
+            kw type
-            },
+            kw unsafe
-            CompletionItem {
+            kw use
-                label: "if",
+            kw while
-                source_range: 108..108,
-                delete: 108..108,
-                insert: "if $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "loop",
-                source_range: 108..108,
-                delete: 108..108,
-                insert: "loop {$0}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 108..108,
-                delete: 108..108,
-                insert: "match $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "return",
-                source_range: 108..108,
-                delete: 108..108,
-                insert: "return;",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 108..108,
-                delete: 108..108,
-                insert: "while $0 {}",
-                kind: Keyword,
-            },
-        ]
        "###
        );
    }
    #[test]
-    fn test_completion_return_value() {
+    fn test_keywords_inside_block() {
-        assert_debug_snapshot!(
+        assert_snapshot!(
-            do_keyword_completion(
+            get_keyword_completions(r"fn quux() { if true { <|> } }"),
-                r"
-                fn quux() -> i32 {
-                    <|>
-                    92
-                }
-                ",
-            ),
            @r###"
-        [
+            kw const
-            CompletionItem {
+            kw extern
-                label: "if",
+            kw fn
-                source_range: 56..56,
+            kw if
-                delete: 56..56,
+            kw if let
-                insert: "if $0 {}",
+            kw impl
-                kind: Keyword,
+            kw let
-            },
+            kw loop
-            CompletionItem {
+            kw match
-                label: "loop",
+            kw mod
-                source_range: 56..56,
+            kw return
-                delete: 56..56,
+            kw static
-                insert: "loop {$0}",
+            kw trait
-                kind: Keyword,
+            kw type
-            },
+            kw unsafe
-            CompletionItem {
+            kw use
-                label: "match",
+            kw while
-                source_range: 56..56,
-                delete: 56..56,
-                insert: "match $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "return",
-                source_range: 56..56,
-                delete: 56..56,
-                insert: "return $0;",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 56..56,
-                delete: 56..56,
-                insert: "while $0 {}",
-                kind: Keyword,
-            },
-        ]
        "###
        );
-        assert_debug_snapshot!(
+    }
-            do_keyword_completion(
+    #[test]
+    fn test_keywords_after_if() {
+        assert_snapshot!(
+            get_keyword_completions(
                r"
                fn quux() {
-                    <|>
+                    if true {
-                    92
+                        ()
+                    } <|>
                }
                ",
            ),
            @r###"
-        [
+            kw const
-            CompletionItem {
+            kw else
-                label: "if",
+            kw else if
-                source_range: 49..49,
+            kw extern
-                delete: 49..49,
+            kw fn
-                insert: "if $0 {}",
+            kw if
-                kind: Keyword,
+            kw if let
-            },
+            kw impl
-            CompletionItem {
+            kw let
-                label: "loop",
+            kw loop
-                source_range: 49..49,
+            kw match
-                delete: 49..49,
+            kw mod
-                insert: "loop {$0}",
+            kw return
-                kind: Keyword,
+            kw static
-            },
+            kw trait
-            CompletionItem {
+            kw type
-                label: "match",
+            kw unsafe
-                source_range: 49..49,
+            kw use
-                delete: 49..49,
+            kw while
-                insert: "match $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "return",
-                source_range: 49..49,
-                delete: 49..49,
-                insert: "return;",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 49..49,
-                delete: 49..49,
-                insert: "while $0 {}",
-                kind: Keyword,
-            },
-        ]
        "###
        );
    }
    #[test]
-    fn dont_add_semi_after_return_if_not_a_statement() {
+    fn test_keywords_in_match_arm() {
-        assert_debug_snapshot!(
+        assert_snapshot!(
-            do_keyword_completion(
+            get_keyword_completions(
                r"
                fn quux() -> i32 {
                    match () {
@@ -451,336 +329,130 @@ mod tests {
                ",
            ),
            @r###"
-        [
+            kw if
-            CompletionItem {
+            kw if let
-                label: "if",
+            kw loop
-                source_range: 97..97,
+            kw match
-                delete: 97..97,
+            kw return
-                insert: "if $0 {}",
+            kw unsafe
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "loop",
-                source_range: 97..97,
-                delete: 97..97,
-                insert: "loop {$0}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 97..97,
-                delete: 97..97,
-                insert: "match $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "return",
-                source_range: 97..97,
-                delete: 97..97,
-                insert: "return $0",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 97..97,
-                delete: 97..97,
-                insert: "while $0 {}",
-                kind: Keyword,
-            },
-        ]
        "###
        );
    }
    #[test]
-    fn last_return_in_block_has_semi() {
+    fn test_keywords_in_trait_def() {
-        assert_debug_snapshot!(
+        assert_snapshot!(
-            do_keyword_completion(
+            get_keyword_completions(r"trait My { <|> }"),
-                r"
-                fn quux() -> i32 {
-                    if condition {
-                        <|>
-                    }
-                }
-                ",
-            ),
            @r###"
-        [
+            kw const
-            CompletionItem {
+            kw fn
-                label: "if",
+            kw type
-                source_range: 95..95,
+            kw unsafe
-                delete: 95..95,
-                insert: "if $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "loop",
-                source_range: 95..95,
-                delete: 95..95,
-                insert: "loop {$0}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 95..95,
-                delete: 95..95,
-                insert: "match $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "return",
-                source_range: 95..95,
-                delete: 95..95,
-                insert: "return $0;",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 95..95,
-                delete: 95..95,
-                insert: "while $0 {}",
-                kind: Keyword,
-            },
-        ]
        "###
        );
-        assert_debug_snapshot!(
+    }
-            do_keyword_completion(
-                r"
+    #[test]
-                fn quux() -> i32 {
+    fn test_keywords_in_impl_def() {
-                    if condition {
+        assert_snapshot!(
-                        <|>
+            get_keyword_completions(r"impl My { <|> }"),
-                    }
-                    let x = 92;
-                    x
-                }
-                ",
-            ),
            @r###"
-        [
+            kw const
-            CompletionItem {
+            kw fn
-                label: "if",
+            kw pub
-                source_range: 95..95,
+            kw type
-                delete: 95..95,
+            kw unsafe
-                insert: "if $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "loop",
-                source_range: 95..95,
-                delete: 95..95,
-                insert: "loop {$0}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 95..95,
-                delete: 95..95,
-                insert: "match $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "return",
-                source_range: 95..95,
-                delete: 95..95,
-                insert: "return $0;",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 95..95,
-                delete: 95..95,
-                insert: "while $0 {}",
-                kind: Keyword,
-            },
-        ]
        "###
        );
    }
    #[test]
-    fn completes_break_and_continue_in_loops() {
+    fn test_keywords_in_loop() {
-        assert_debug_snapshot!(
+        assert_snapshot!(
-            do_keyword_completion(
+            get_keyword_completions(r"fn my() { loop { <|> } }"),
-                r"
-                fn quux() -> i32 {
-                    loop { <|> }
-                }
-                ",
-            ),
            @r###"
-        [
+            kw break
-            CompletionItem {
+            kw const
-                label: "break",
+            kw continue
-                source_range: 63..63,
+            kw extern
-                delete: 63..63,
+            kw fn
-                insert: "break;",
+            kw if
-                kind: Keyword,
+            kw if let
-            },
+            kw impl
-            CompletionItem {
+            kw let
-                label: "continue",
+            kw loop
-                source_range: 63..63,
+            kw match
-                delete: 63..63,
+            kw mod
-                insert: "continue;",
+            kw return
-                kind: Keyword,
+            kw static
-            },
+            kw trait
-            CompletionItem {
+            kw type
-                label: "if",
+            kw unsafe
-                source_range: 63..63,
+            kw use
-                delete: 63..63,
+            kw while
-                insert: "if $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "loop",
-                source_range: 63..63,
-                delete: 63..63,
-                insert: "loop {$0}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 63..63,
-                delete: 63..63,
-                insert: "match $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "return",
-                source_range: 63..63,
-                delete: 63..63,
-                insert: "return $0;",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 63..63,
-                delete: 63..63,
-                insert: "while $0 {}",
-                kind: Keyword,
-            },
-        ]
        "###
        );
+    }
-        // No completion: lambda isolates control flow
+    #[test]
-        assert_debug_snapshot!(
+    fn test_keywords_after_unsafe_in_item_list() {
-            do_keyword_completion(
+        assert_snapshot!(
-                r"
+            get_keyword_completions(r"unsafe <|>"),
-                fn quux() -> i32 {
-                    loop { || { <|> } }
-                }
-                ",
-            ),
            @r###"
-        [
+            kw fn
-            CompletionItem {
+            kw impl
-                label: "if",
+            kw trait
-                source_range: 68..68,
-                delete: 68..68,
-                insert: "if $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "loop",
-                source_range: 68..68,
-                delete: 68..68,
-                insert: "loop {$0}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 68..68,
-                delete: 68..68,
-                insert: "match $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "return",
-                source_range: 68..68,
-                delete: 68..68,
-                insert: "return $0;",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 68..68,
-                delete: 68..68,
-                insert: "while $0 {}",
-                kind: Keyword,
-            },
-        ]
        "###
        );
    }
    #[test]
-    fn no_semi_after_break_continue_in_expr() {
+    fn test_keywords_after_unsafe_in_block_expr() {
-        assert_debug_snapshot!(
+        assert_snapshot!(
-            do_keyword_completion(
+            get_keyword_completions(r"fn my_fn() { unsafe <|> }"),
-                r"
-                fn f() {
-                    loop {
-                        match () {
-                            () => br<|>
-                        }
-                    }
-                }
-                ",
-            ),
            @r###"
-        [
+            kw fn
-            CompletionItem {
+            kw impl
-                label: "break",
+            kw trait
-                source_range: 122..124,
-                delete: 122..124,
-                insert: "break",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "continue",
-                source_range: 122..124,
-                delete: 122..124,
-                insert: "continue",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "if",
-                source_range: 122..124,
-                delete: 122..124,
-                insert: "if $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "loop",
-                source_range: 122..124,
-                delete: 122..124,
-                insert: "loop {$0}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 122..124,
-                delete: 122..124,
-                insert: "match $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "return",
-                source_range: 122..124,
-                delete: 122..124,
-                insert: "return",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 122..124,
-                delete: 122..124,
-                insert: "while $0 {}",
-                kind: Keyword,
-            },
-        ]
        "###
-        )
+        );
+    }
+    #[test]
+    fn test_mut_in_ref_and_in_fn_parameters_list() {
+        assert_snapshot!(
+            get_keyword_completions(r"fn my_fn(&<|>) {}"),
+            @r###"
+            kw mut
+        "###
+        );
+        assert_snapshot!(
+            get_keyword_completions(r"fn my_fn(<|>) {}"),
+            @r###"
+            kw mut
+        "###
+        );
+        assert_snapshot!(
+            get_keyword_completions(r"fn my_fn() { let &<|> }"),
+            @r###"
+            kw mut
+        "###
+        );
+    }
+    #[test]
+    fn test_where_keyword() {
+        assert_snapshot!(
+            get_keyword_completions(r"trait A <|>"),
+            @r###"
+            kw where
+        "###
+        );
+        assert_snapshot!(
+            get_keyword_completions(r"impl A <|>"),
+            @r###"
+            kw where
+        "###
+        );
    }
 }
diff --git a/crates/ra_ide/src/completion/complete_postfix.rs b/crates/ra_ide/src/completion/complete_postfix.rs
index 59b58bf98..b878aeb0a 100644
--- a/crates/ra_ide/src/completion/complete_postfix.rs
+++ b/crates/ra_ide/src/completion/complete_postfix.rs
@@ -91,7 +91,7 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
            &dot_receiver,
            "if",
            "if expr {}",
-            &format!("if {} {{$0}}", receiver_text),
+            &format!("if {} {{\n    $0\n}}", receiver_text),
        )
        .add_to(acc);
        postfix_snippet(
@@ -100,7 +100,7 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
            &dot_receiver,
            "while",
            "while expr {}",
-            &format!("while {} {{\n$0\n}}", receiver_text),
+            &format!("while {} {{\n    $0\n}}", receiver_text),
        )
        .add_to(acc);
    }
@@ -283,7 +283,7 @@ mod tests {
                label: "if",
                source_range: 89..89,
                delete: 85..89,
-                insert: "if bar {$0}",
+                insert: "if bar {\n    $0\n}",
                detail: "if expr {}",
            },
            CompletionItem {
@@ -318,7 +318,7 @@ mod tests {
                label: "while",
                source_range: 89..89,
                delete: 85..89,
-                insert: "while bar {\n$0\n}",
+                insert: "while bar {\n    $0\n}",
                detail: "while expr {}",
            },
        ]
diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs
index c4646b727..560fb19e6 100644
--- a/crates/ra_ide/src/completion/completion_context.rs
+++ b/crates/ra_ide/src/completion/completion_context.rs
@@ -5,12 +5,17 @@ use ra_db::SourceDatabase;
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
    algo::{find_covering_element, find_node_at_offset},
-    ast, match_ast, AstNode,
+    ast, match_ast, AstNode, NodeOrToken,
    SyntaxKind::*,
    SyntaxNode, SyntaxToken, TextRange, TextSize,
 };
 use ra_text_edit::Indel;
+use super::patterns::{
+    has_bind_pat_parent, has_block_expr_parent, has_impl_as_prev_sibling, has_impl_parent,
+    has_item_list_or_source_file_parent, has_ref_parent, has_trait_as_prev_sibling,
+    has_trait_parent, if_is_prev, is_in_loop_body, is_match_arm, unsafe_is_prev,
+};
 use crate::{call_info::ActiveParameter, completion::CompletionConfig, FilePosition};
 use test_utils::mark;
@@ -60,6 +65,18 @@ pub(crate) struct CompletionContext<'a> {
    pub(super) is_path_type: bool,
    pub(super) has_type_args: bool,
    pub(super) attribute_under_caret: Option<ast::Attr>,
+    pub(super) unsafe_is_prev: bool,
+    pub(super) if_is_prev: bool,
+    pub(super) block_expr_parent: bool,
+    pub(super) bind_pat_parent: bool,
+    pub(super) ref_pat_parent: bool,
+    pub(super) in_loop_body: bool,
+    pub(super) has_trait_parent: bool,
+    pub(super) has_impl_parent: bool,
+    pub(super) trait_as_prev_sibling: bool,
+    pub(super) impl_as_prev_sibling: bool,
+    pub(super) is_match_arm: bool,
+    pub(super) has_item_list_or_source_file_parent: bool,
 }
 impl<'a> CompletionContext<'a> {
@@ -118,6 +135,18 @@ impl<'a> CompletionContext<'a> {
            has_type_args: false,
            dot_receiver_is_ambiguous_float_literal: false,
            attribute_under_caret: None,
+            unsafe_is_prev: false,
+            in_loop_body: false,
+            ref_pat_parent: false,
+            bind_pat_parent: false,
+            block_expr_parent: false,
+            has_trait_parent: false,
+            has_impl_parent: false,
+            trait_as_prev_sibling: false,
+            impl_as_prev_sibling: false,
+            if_is_prev: false,
+            is_match_arm: false,
+            has_item_list_or_source_file_parent: false,
        };
        let mut original_file = original_file.syntax().clone();
@@ -159,7 +188,7 @@ impl<'a> CompletionContext<'a> {
                break;
            }
        }
+        ctx.fill_keyword_patterns(&hypothetical_file, offset);
        ctx.fill(&original_file, hypothetical_file, offset);
        Some(ctx)
    }
@@ -188,6 +217,24 @@ impl<'a> CompletionContext<'a> {
        self.sema.scope_at_offset(&self.token.parent(), self.offset)
    }
+    fn fill_keyword_patterns(&mut self, file_with_fake_ident: &SyntaxNode, offset: TextSize) {
+        let fake_ident_token = file_with_fake_ident.token_at_offset(offset).right_biased().unwrap();
+        let syntax_element = NodeOrToken::Token(fake_ident_token.clone());
+        self.block_expr_parent = has_block_expr_parent(syntax_element.clone());
+        self.unsafe_is_prev = unsafe_is_prev(syntax_element.clone());
+        self.if_is_prev = if_is_prev(syntax_element.clone());
+        self.bind_pat_parent = has_bind_pat_parent(syntax_element.clone());
+        self.ref_pat_parent = has_ref_parent(syntax_element.clone());
+        self.in_loop_body = is_in_loop_body(syntax_element.clone());
+        self.has_trait_parent = has_trait_parent(syntax_element.clone());
+        self.has_impl_parent = has_impl_parent(syntax_element.clone());
+        self.impl_as_prev_sibling = has_impl_as_prev_sibling(syntax_element.clone());
+        self.trait_as_prev_sibling = has_trait_as_prev_sibling(syntax_element.clone());
+        self.is_match_arm = is_match_arm(syntax_element.clone());
+        self.has_item_list_or_source_file_parent =
+            has_item_list_or_source_file_parent(syntax_element.clone());
+    }
    fn fill(
        &mut self,
        original_file: &SyntaxNode,
@@ -334,6 +381,7 @@ impl<'a> CompletionContext<'a> {
            self.is_path_type = path.syntax().parent().and_then(ast::PathType::cast).is_some();
            self.has_type_args = segment.type_arg_list().is_some();
+            #[allow(deprecated)]
            if let Some(path) = hir::Path::from_ast(path.clone()) {
                if let Some(path_prefix) = path.qualifier() {
                    self.path_prefix = Some(path_prefix);
diff --git a/crates/ra_ide/src/completion/completion_item.rs b/crates/ra_ide/src/completion/completion_item.rs
index cfb7c1e38..98348b349 100644
--- a/crates/ra_ide/src/completion/completion_item.rs
+++ b/crates/ra_ide/src/completion/completion_item.rs
@@ -125,6 +125,32 @@ pub enum CompletionItemKind {
    Attribute,
 }
+impl CompletionItemKind {
+    #[cfg(test)]
+    pub(crate) fn tag(&self) -> &'static str {
+        match self {
+            CompletionItemKind::Snippet => "sn",
+            CompletionItemKind::Keyword => "kw",
+            CompletionItemKind::Module => "md",
+            CompletionItemKind::Function => "fn",
+            CompletionItemKind::BuiltinType => "bt",
+            CompletionItemKind::Struct => "st",
+            CompletionItemKind::Enum => "en",
+            CompletionItemKind::EnumVariant => "ev",
+            CompletionItemKind::Binding => "bn",
+            CompletionItemKind::Field => "fd",
+            CompletionItemKind::Static => "sc",
+            CompletionItemKind::Const => "ct",
+            CompletionItemKind::Trait => "tt",
+            CompletionItemKind::TypeAlias => "ta",
+            CompletionItemKind::Method => "me",
+            CompletionItemKind::TypeParam => "tp",
+            CompletionItemKind::Macro => "ma",
+            CompletionItemKind::Attribute => "at",
+        }
+    }
+}
 #[derive(Debug, PartialEq, Eq, Copy, Clone)]
 pub(crate) enum CompletionKind {
    /// Parser-based keyword completion.
diff --git a/crates/ra_ide/src/completion/patterns.rs b/crates/ra_ide/src/completion/patterns.rs
new file mode 100644
index 000000000..b2fe13280
--- /dev/null
+++ b/crates/ra_ide/src/completion/patterns.rs
@@ -0,0 +1,194 @@
+//! Patterns telling us certain facts about current syntax element, they are used in completion context
+use ra_syntax::{
+    algo::non_trivia_sibling,
+    ast::{self, LoopBodyOwner},
+    match_ast, AstNode, Direction, NodeOrToken, SyntaxElement,
+    SyntaxKind::*,
+    SyntaxNode, SyntaxToken,
+};
+#[cfg(test)]
+use crate::completion::test_utils::check_pattern_is_applicable;
+pub(crate) fn has_trait_parent(element: SyntaxElement) -> bool {
+    not_same_range_ancestor(element)
+        .filter(|it| it.kind() == ITEM_LIST)
+        .and_then(|it| it.parent())
+        .filter(|it| it.kind() == TRAIT_DEF)
+        .is_some()
+}
+#[test]
+fn test_has_trait_parent() {
+    check_pattern_is_applicable(r"trait A { f<|> }", has_trait_parent);
+}
+pub(crate) fn has_impl_parent(element: SyntaxElement) -> bool {
+    not_same_range_ancestor(element)
+        .filter(|it| it.kind() == ITEM_LIST)
+        .and_then(|it| it.parent())
+        .filter(|it| it.kind() == IMPL_DEF)
+        .is_some()
+}
+#[test]
+fn test_has_impl_parent() {
+    check_pattern_is_applicable(r"impl A { f<|> }", has_impl_parent);
+}
+pub(crate) fn has_block_expr_parent(element: SyntaxElement) -> bool {
+    not_same_range_ancestor(element).filter(|it| it.kind() == BLOCK_EXPR).is_some()
+}
+#[test]
+fn test_has_block_expr_parent() {
+    check_pattern_is_applicable(r"fn my_fn() { let a = 2; f<|> }", has_block_expr_parent);
+}
+pub(crate) fn has_bind_pat_parent(element: SyntaxElement) -> bool {
+    element.ancestors().find(|it| it.kind() == BIND_PAT).is_some()
+}
+#[test]
+fn test_has_bind_pat_parent() {
+    check_pattern_is_applicable(r"fn my_fn(m<|>) {}", has_bind_pat_parent);
+    check_pattern_is_applicable(r"fn my_fn() { let m<|> }", has_bind_pat_parent);
+}
+pub(crate) fn has_ref_parent(element: SyntaxElement) -> bool {
+    not_same_range_ancestor(element)
+        .filter(|it| it.kind() == REF_PAT || it.kind() == REF_EXPR)
+        .is_some()
+}
+#[test]
+fn test_has_ref_parent() {
+    check_pattern_is_applicable(r"fn my_fn(&m<|>) {}", has_ref_parent);
+    check_pattern_is_applicable(r"fn my() { let &m<|> }", has_ref_parent);
+}
+pub(crate) fn has_item_list_or_source_file_parent(element: SyntaxElement) -> bool {
+    let ancestor = not_same_range_ancestor(element);
+    if !ancestor.is_some() {
+        return true;
+    }
+    ancestor.filter(|it| it.kind() == SOURCE_FILE || it.kind() == ITEM_LIST).is_some()
+}
+#[test]
+fn test_has_item_list_or_source_file_parent() {
+    check_pattern_is_applicable(r"i<|>", has_item_list_or_source_file_parent);
+    check_pattern_is_applicable(r"impl { f<|> }", has_item_list_or_source_file_parent);
+}
+pub(crate) fn is_match_arm(element: SyntaxElement) -> bool {
+    not_same_range_ancestor(element.clone()).filter(|it| it.kind() == MATCH_ARM).is_some()
+        && previous_sibling_or_ancestor_sibling(element)
+            .and_then(|it| it.into_token())
+            .filter(|it| it.kind() == FAT_ARROW)
+            .is_some()
+}
+#[test]
+fn test_is_match_arm() {
+    check_pattern_is_applicable(r"fn my_fn() { match () { () => m<|> } }", is_match_arm);
+}
+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)
+        .is_some()
+}
+#[test]
+fn test_unsafe_is_prev() {
+    check_pattern_is_applicable(r"unsafe i<|>", unsafe_is_prev);
+}
+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)
+        .is_some()
+}
+#[test]
+fn test_if_is_prev() {
+    check_pattern_is_applicable(r"if l<|>", if_is_prev);
+}
+pub(crate) fn has_trait_as_prev_sibling(element: SyntaxElement) -> bool {
+    previous_sibling_or_ancestor_sibling(element).filter(|it| it.kind() == TRAIT_DEF).is_some()
+}
+#[test]
+fn test_has_trait_as_prev_sibling() {
+    check_pattern_is_applicable(r"trait A w<|> {}", has_trait_as_prev_sibling);
+}
+pub(crate) fn has_impl_as_prev_sibling(element: SyntaxElement) -> bool {
+    previous_sibling_or_ancestor_sibling(element).filter(|it| it.kind() == IMPL_DEF).is_some()
+}
+#[test]
+fn test_has_impl_as_prev_sibling() {
+    check_pattern_is_applicable(r"impl A w<|> {}", has_impl_as_prev_sibling);
+}
+pub(crate) fn is_in_loop_body(element: SyntaxElement) -> bool {
+    let leaf = match element {
+        NodeOrToken::Node(node) => node,
+        NodeOrToken::Token(token) => token.parent(),
+    };
+    for node in leaf.ancestors() {
+        if node.kind() == FN_DEF || node.kind() == LAMBDA_EXPR {
+            break;
+        }
+        let loop_body = match_ast! {
+            match node {
+                ast::ForExpr(it) => it.loop_body(),
+                ast::WhileExpr(it) => it.loop_body(),
+                ast::LoopExpr(it) => it.loop_body(),
+                _ => None,
+            }
+        };
+        if let Some(body) = loop_body {
+            if body.syntax().text_range().contains_range(leaf.text_range()) {
+                return true;
+            }
+        }
+    }
+    false
+}
+fn not_same_range_ancestor(element: SyntaxElement) -> Option<SyntaxNode> {
+    element
+        .ancestors()
+        .take_while(|it| it.text_range() == element.text_range())
+        .last()
+        .and_then(|it| it.parent())
+}
+fn previous_non_trivia_token(token: SyntaxToken) -> Option<SyntaxToken> {
+    let mut token = token.prev_token();
+    while let Some(inner) = token.clone() {
+        if !inner.kind().is_trivia() {
+            return Some(inner);
+        } else {
+            token = inner.prev_token();
+        }
+    }
+    None
+}
+fn previous_sibling_or_ancestor_sibling(element: SyntaxElement) -> Option<SyntaxElement> {
+    let token_sibling = non_trivia_sibling(element.clone(), Direction::Prev);
+    if let Some(sibling) = token_sibling {
+        Some(sibling)
+    } else {
+        // if not trying to find first ancestor which has such a sibling
+        let node = match element {
+            NodeOrToken::Node(node) => node,
+            NodeOrToken::Token(token) => token.parent(),
+        };
+        let range = node.text_range();
+        let top_node = node.ancestors().take_while(|it| it.text_range() == range).last()?;
+        let prev_sibling_node = top_node.ancestors().find(|it| {
+            non_trivia_sibling(NodeOrToken::Node(it.to_owned()), Direction::Prev).is_some()
+        })?;
+        non_trivia_sibling(NodeOrToken::Node(prev_sibling_node), Direction::Prev)
+    }
+}
diff --git a/crates/ra_ide/src/completion/test_utils.rs b/crates/ra_ide/src/completion/test_utils.rs
index bf22452a2..1e16a43ca 100644
--- a/crates/ra_ide/src/completion/test_utils.rs
+++ b/crates/ra_ide/src/completion/test_utils.rs
@@ -5,25 +5,63 @@ use crate::{
    mock_analysis::{analysis_and_position, single_file_with_position},
    CompletionItem,
 };
+use hir::Semantics;
+use ra_syntax::{AstNode, NodeOrToken, SyntaxElement};
 pub(crate) fn do_completion(code: &str, kind: CompletionKind) -> Vec<CompletionItem> {
    do_completion_with_options(code, kind, &CompletionConfig::default())
 }
+pub(crate) fn completion_list(code: &str, kind: CompletionKind) -> String {
+    completion_list_with_options(code, kind, &CompletionConfig::default())
+}
 pub(crate) fn do_completion_with_options(
    code: &str,
    kind: CompletionKind,
    options: &CompletionConfig,
 ) -> Vec<CompletionItem> {
+    let mut kind_completions: Vec<CompletionItem> = get_all_completion_items(code, options)
+        .into_iter()
+        .filter(|c| c.completion_kind == kind)
+        .collect();
+    kind_completions.sort_by(|l, r| l.label().cmp(r.label()));
+    kind_completions
+}
+fn get_all_completion_items(code: &str, options: &CompletionConfig) -> Vec<CompletionItem> {
    let (analysis, position) = if code.contains("//-") {
        analysis_and_position(code)
    } else {
        single_file_with_position(code)
    };
-    let completions = analysis.completions(options, position).unwrap().unwrap();
+    analysis.completions(options, position).unwrap().unwrap().into()
-    let completion_items: Vec<CompletionItem> = completions.into();
+}
-    let mut kind_completions: Vec<CompletionItem> =
-        completion_items.into_iter().filter(|c| c.completion_kind == kind).collect();
+pub(crate) fn completion_list_with_options(
+    code: &str,
+    kind: CompletionKind,
+    options: &CompletionConfig,
+) -> String {
+    let mut kind_completions: Vec<CompletionItem> = get_all_completion_items(code, options)
+        .into_iter()
+        .filter(|c| c.completion_kind == kind)
+        .collect();
    kind_completions.sort_by_key(|c| c.label().to_owned());
    kind_completions
+        .into_iter()
+        .map(|it| format!("{} {}\n", it.kind().unwrap().tag(), it.label()))
+        .collect()
+}
+pub(crate) fn check_pattern_is_applicable(code: &str, check: fn(SyntaxElement) -> bool) {
+    let (analysis, pos) = single_file_with_position(code);
+    analysis
+        .with_db(|db| {
+            let sema = Semantics::new(db);
+            let original_file = sema.parse(pos.file_id);
+            let token = original_file.syntax().token_at_offset(pos.offset).left_biased().unwrap();
+            assert!(check(NodeOrToken::Token(token)));
+        })
+        .unwrap();
 }
diff --git a/crates/ra_ide/src/diagnostics.rs b/crates/ra_ide/src/diagnostics.rs
index f44feaf69..fd9abb55b 100644
--- a/crates/ra_ide/src/diagnostics.rs
+++ b/crates/ra_ide/src/diagnostics.rs
@@ -11,7 +11,7 @@ use hir::{
    Semantics,
 };
 use itertools::Itertools;
-use ra_db::{RelativePath, SourceDatabase, SourceDatabaseExt};
+use ra_db::SourceDatabase;
 use ra_ide_db::RootDatabase;
 use ra_prof::profile;
 use ra_syntax::{
@@ -57,14 +57,10 @@ pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic>
    })
    .on::<hir::diagnostics::UnresolvedModule, _>(|d| {
        let original_file = d.source().file_id.original_file(db);
-        let source_root = db.file_source_root(original_file);
+        let fix = Fix::new(
-        let path = db
+            "Create module",
-            .file_relative_path(original_file)
+            FileSystemEdit::CreateFile { anchor: original_file, dst: d.candidate.clone() }.into(),
-            .parent()
+        );
-            .unwrap_or_else(|| RelativePath::new(""))
-            .join(&d.candidate);
-        let fix =
-            Fix::new("Create module", FileSystemEdit::CreateFile { source_root, path }.into());
        res.borrow_mut().push(Diagnostic {
            range: sema.diagnostics_range(d).range,
            message: d.message(),
@@ -187,7 +183,8 @@ fn check_struct_shorthand_initialization(
        if let (Some(name_ref), Some(expr)) = (record_field.name_ref(), record_field.expr()) {
            let field_name = name_ref.syntax().text().to_string();
            let field_expr = expr.syntax().text().to_string();
-            if field_name == field_expr {
+            let field_name_is_tup_index = name_ref.as_tuple_field().is_some();
+            if field_name == field_expr && !field_name_is_tup_index {
                let mut edit_builder = TextEditBuilder::default();
                edit_builder.delete(record_field.syntax().text_range());
                edit_builder.insert(record_field.syntax().text_range().start(), field_name);
@@ -611,10 +608,10 @@ mod tests {
                            source_file_edits: [],
                            file_system_edits: [
                                CreateFile {
-                                    source_root: SourceRootId(
+                                    anchor: FileId(
-                                        0,
+                                        1,
                                    ),
-                                    path: "foo.rs",
+                                    dst: "foo.rs",
                                },
                            ],
                            is_snippet: false,
@@ -719,6 +716,18 @@ mod tests {
        "#,
            check_struct_shorthand_initialization,
        );
+        check_not_applicable(
+            r#"
+            struct A(usize);
+            fn main() {
+                A {
+                    0: 0
+                }
+            }
+        "#,
+            check_struct_shorthand_initialization,
+        );
        check_apply(
            r#"
diff --git a/crates/ra_ide/src/lib.rs b/crates/ra_ide/src/lib.rs
index 28f686767..375da1f45 100644
--- a/crates/ra_ide/src/lib.rs
+++ b/crates/ra_ide/src/lib.rs
@@ -440,12 +440,14 @@ impl Analysis {
    /// Computes syntax highlighting for the given file
    pub fn highlight(&self, file_id: FileId) -> Cancelable<Vec<HighlightedRange>> {
-        self.with_db(|db| syntax_highlighting::highlight(db, file_id, None))
+        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>> {
-        self.with_db(|db| syntax_highlighting::highlight(db, frange.file_id, Some(frange.range)))
+        self.with_db(|db| {
+            syntax_highlighting::highlight(db, frange.file_id, Some(frange.range), false)
+        })
    }
    /// Computes syntax highlighting for the given file.
diff --git a/crates/ra_ide/src/prime_caches.rs b/crates/ra_ide/src/prime_caches.rs
index 90bf7d25f..c5ab5a1d8 100644
--- a/crates/ra_ide/src/prime_caches.rs
+++ b/crates/ra_ide/src/prime_caches.rs
@@ -7,6 +7,6 @@ use crate::{FileId, RootDatabase};
 pub(crate) fn prime_caches(db: &RootDatabase, files: Vec<FileId>) {
    for file in files {
-        let _ = crate::syntax_highlighting::highlight(db, file, None);
+        let _ = crate::syntax_highlighting::highlight(db, file, None, false);
    }
 }
diff --git a/crates/ra_ide/src/references/rename.rs b/crates/ra_ide/src/references/rename.rs
index 546224b50..99c2581b7 100644
--- a/crates/ra_ide/src/references/rename.rs
+++ b/crates/ra_ide/src/references/rename.rs
@@ -1,7 +1,7 @@
 //! FIXME: write short doc here
 use hir::{Module, ModuleDef, ModuleSource, Semantics};
-use ra_db::{RelativePath, RelativePathBuf, SourceDatabaseExt};
+use ra_db::{RelativePathBuf, SourceDatabaseExt};
 use ra_ide_db::{
    defs::{classify_name, classify_name_ref, Definition, NameClass, NameRefClass},
    RootDatabase,
@@ -111,23 +111,14 @@ fn rename_mod(
        ModuleSource::SourceFile(..) => {
            let mod_path: RelativePathBuf = db.file_relative_path(file_id);
            // mod is defined in path/to/dir/mod.rs
-            let dst_path = if mod_path.file_stem() == Some("mod") {
+            let dst = if mod_path.file_stem() == Some("mod") {
-                mod_path
+                format!("../{}/mod.rs", new_name)
-                    .parent()
-                    .and_then(|p| p.parent())
-                    .or_else(|| Some(RelativePath::new("")))
-                    .map(|p| p.join(new_name).join("mod.rs"))
            } else {
-                Some(mod_path.with_file_name(new_name).with_extension("rs"))
+                format!("{}.rs", new_name)
            };
-            if let Some(path) = dst_path {
+            let move_file =
-                let move_file = FileSystemEdit::MoveFile {
+                FileSystemEdit::MoveFile { src: file_id, anchor: position.file_id, dst };
-                    src: file_id,
+            file_system_edits.push(move_file);
-                    dst_source_root: db.file_source_root(position.file_id),
-                    dst_path: path,
-                };
-                file_system_edits.push(move_file);
-            }
        }
        ModuleSource::Module(..) => {}
    }
@@ -644,16 +635,16 @@ mod tests {
    #[test]
    fn test_rename_mod() {
        let (analysis, position) = analysis_and_position(
-            "
+            r#"
-            //- /lib.rs
+//- /lib.rs
-            mod bar;
+mod bar;
-            //- /bar.rs
+//- /bar.rs
-            mod foo<|>;
+mod foo<|>;
-            //- /bar/foo.rs
+//- /bar/foo.rs
-            // emtpy
+// emtpy
-            ",
+            "#,
        );
        let new_name = "foo2";
        let source_change = analysis.rename(position, new_name).unwrap();
@@ -683,10 +674,10 @@ mod tests {
                            src: FileId(
                                3,
                            ),
-                            dst_source_root: SourceRootId(
+                            anchor: FileId(
-                                0,
+                                2,
                            ),
-                            dst_path: "bar/foo2.rs",
+                            dst: "foo2.rs",
                        },
                    ],
                    is_snippet: false,
@@ -699,18 +690,18 @@ mod tests {
    #[test]
    fn test_rename_mod_in_use_tree() {
        let (analysis, position) = analysis_and_position(
-            "
+            r#"
-            //- /main.rs
+//- /main.rs
-            pub mod foo;
+pub mod foo;
-            pub mod bar;
+pub mod bar;
-            fn main() {}
+fn main() {}
-            //- /foo.rs
+//- /foo.rs
-            pub struct FooContent;
+pub struct FooContent;
-            //- /bar.rs
+//- /bar.rs
-            use crate::foo<|>::FooContent;
+use crate::foo<|>::FooContent;
-            ",
+            "#,
        );
        let new_name = "qux";
        let source_change = analysis.rename(position, new_name).unwrap();
@@ -753,10 +744,10 @@ mod tests {
                            src: FileId(
                                2,
                            ),
-                            dst_source_root: SourceRootId(
+                            anchor: FileId(
-                                0,
+                                3,
                            ),
-                            dst_path: "qux.rs",
+                            dst: "qux.rs",
                        },
                    ],
                    is_snippet: false,
@@ -769,12 +760,12 @@ mod tests {
    #[test]
    fn test_rename_mod_in_dir() {
        let (analysis, position) = analysis_and_position(
-            "
+            r#"
-            //- /lib.rs
+//- /lib.rs
-            mod fo<|>o;
+mod fo<|>o;
-            //- /foo/mod.rs
+//- /foo/mod.rs
-            // emtpy
+// emtpy
-            ",
+            "#,
        );
        let new_name = "foo2";
        let source_change = analysis.rename(position, new_name).unwrap();
@@ -804,10 +795,10 @@ mod tests {
                            src: FileId(
                                2,
                            ),
-                            dst_source_root: SourceRootId(
+                            anchor: FileId(
-                                0,
+                                1,
                            ),
-                            dst_path: "foo2/mod.rs",
+                            dst: "../foo2/mod.rs",
                        },
                    ],
                    is_snippet: false,
@@ -844,19 +835,19 @@ mod tests {
    #[test]
    fn test_rename_mod_filename_and_path() {
        let (analysis, position) = analysis_and_position(
-            "
+            r#"
-            //- /lib.rs
+//- /lib.rs
-            mod bar;
+mod bar;
-            fn f() {
+fn f() {
-                bar::foo::fun()
+    bar::foo::fun()
-            }
+}
-            //- /bar.rs
+//- /bar.rs
-            pub mod foo<|>;
+pub mod foo<|>;
-            //- /bar/foo.rs
+//- /bar/foo.rs
-            // pub fn fun() {}
+// pub fn fun() {}
-            ",
+            "#,
        );
        let new_name = "foo2";
        let source_change = analysis.rename(position, new_name).unwrap();
@@ -899,10 +890,10 @@ mod tests {
                            src: FileId(
                                3,
                            ),
-                            dst_source_root: SourceRootId(
+                            anchor: FileId(
-                                0,
+                                2,
                            ),
-                            dst_path: "bar/foo2.rs",
+                            dst: "foo2.rs",
                        },
                    ],
                    is_snippet: false,
diff --git a/crates/ra_ide/src/snapshots/highlight_doctest.html b/crates/ra_ide/src/snapshots/highlight_doctest.html
index 0ae8c7efc..f92a0aba5 100644
--- a/crates/ra_ide/src/snapshots/highlight_doctest.html
+++ b/crates/ra_ide/src/snapshots/highlight_doctest.html
@@ -25,22 +25,30 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .variable           { color: #DCDCCC; }
 .format_specifier   { color: #CC696B; }
 .mutable            { text-decoration: underline; }
+.unresolved_reference { color: #FC5555; }
+.escape_sequence    { color: #94BFF3; }
 .keyword            { color: #F0DFAF; font-weight: bold; }
 .keyword.unsafe     { color: #BC8383; font-weight: bold; }
 .control            { font-style: italic; }
 </style>
-<pre><code><span class="keyword">impl</span> <span class="unresolved_reference">Foo</span> {
+<pre><code><span class="keyword">struct</span> <span class="struct declaration">Foo</span> {
+    <span class="field declaration">bar</span>: <span class="builtin_type">bool</span>,
+}
+<span class="keyword">impl</span> <span class="struct">Foo</span> {
+    <span class="keyword">pub</span> <span class="keyword">const</span> <span class="constant declaration">bar</span>: <span class="builtin_type">bool</span> = <span class="bool_literal">true</span>;
    <span class="comment">/// Constructs a new `Foo`.</span>
    <span class="comment">///</span>
    <span class="comment">/// # Examples</span>
    <span class="comment">///</span>
    <span class="comment">/// ```</span>
    <span class="comment">/// #</span> <span class="attribute">#![</span><span class="function attribute">allow</span><span class="attribute">(unused_mut)]</span>
-    <span class="comment">/// </span><span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">foo</span>: <span class="unresolved_reference">Foo</span> = <span class="unresolved_reference">Foo</span>::<span class="unresolved_reference">new</span>();
+    <span class="comment">/// </span><span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">foo</span>: <span class="struct">Foo</span> = <span class="struct">Foo</span>::<span class="function">new</span>();
    <span class="comment">/// ```</span>
-    <span class="keyword">pub</span> <span class="keyword">const</span> <span class="keyword">fn</span> <span class="function declaration">new</span>() -&gt; <span class="unresolved_reference">Foo</span> {
+    <span class="keyword">pub</span> <span class="keyword">const</span> <span class="keyword">fn</span> <span class="function declaration">new</span>() -&gt; <span class="struct">Foo</span> {
-        <span class="unresolved_reference">Foo</span> { }
+        <span class="struct">Foo</span> { <span class="field">bar</span>: <span class="bool_literal">true</span> }
    }
    <span class="comment">/// `bar` method on `Foo`.</span>
@@ -48,11 +56,15 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
    <span class="comment">/// # Examples</span>
    <span class="comment">///</span>
    <span class="comment">/// ```</span>
-    <span class="comment">/// </span><span class="keyword">let</span> <span class="variable declaration">foo</span> = <span class="unresolved_reference">Foo</span>::<span class="unresolved_reference">new</span>();
+    <span class="comment">/// </span><span class="keyword">use</span> <span class="module">x</span>::<span class="module">y</span>;
+    <span class="comment">///</span>
+    <span class="comment">/// </span><span class="keyword">let</span> <span class="variable declaration">foo</span> = <span class="struct">Foo</span>::<span class="function">new</span>();
    <span class="comment">///</span>
    <span class="comment">/// </span><span class="comment">// calls bar on foo</span>
    <span class="comment">/// </span><span class="macro">assert!</span>(foo.bar());
    <span class="comment">///</span>
+    <span class="comment">/// </span><span class="keyword">let</span> <span class="variable declaration">bar</span> = <span class="variable">foo</span>.<span class="field">bar</span> || <span class="struct">Foo</span>::<span class="constant">bar</span>;
+    <span class="comment">///</span>
    <span class="comment">/// </span><span class="comment">/* multi-line
    </span><span class="comment">/// </span><span class="comment">       comment */</span>
    <span class="comment">///</span>
@@ -62,8 +74,12 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
    <span class="comment">///</span>
    <span class="comment">/// ```</span>
    <span class="comment">///</span>
+    <span class="comment">/// ```rust,no_run</span>
+    <span class="comment">/// </span><span class="keyword">let</span> <span class="variable declaration">foobar</span> = <span class="struct">Foo</span>::<span class="function">new</span>().<span class="function">bar</span>();
    <span class="comment">/// ```</span>
-    <span class="comment">/// </span><span class="keyword">let</span> <span class="variable declaration">foobar</span> = <span class="unresolved_reference">Foo</span>::<span class="unresolved_reference">new</span>().<span class="unresolved_reference">bar</span>();
+    <span class="comment">///</span>
+    <span class="comment">/// ```sh</span>
+    <span class="comment">/// echo 1</span>
    <span class="comment">/// ```</span>
    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration">foo</span>(&<span class="self_keyword">self</span>) -&gt; <span class="builtin_type">bool</span> {
        <span class="bool_literal">true</span>
diff --git a/crates/ra_ide/src/snapshots/highlight_injection.html b/crates/ra_ide/src/snapshots/highlight_injection.html
index dec06eb51..47dbd7bc8 100644
--- a/crates/ra_ide/src/snapshots/highlight_injection.html
+++ b/crates/ra_ide/src/snapshots/highlight_injection.html
@@ -25,6 +25,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .variable           { color: #DCDCCC; }
 .format_specifier   { color: #CC696B; }
 .mutable            { text-decoration: underline; }
+.unresolved_reference { color: #FC5555; }
+.escape_sequence    { color: #94BFF3; }
 .keyword            { color: #F0DFAF; font-weight: bold; }
 .keyword.unsafe     { color: #BC8383; font-weight: bold; }
diff --git a/crates/ra_ide/src/snapshots/highlight_strings.html b/crates/ra_ide/src/snapshots/highlight_strings.html
index 849eb3b73..b46fa44c6 100644
--- a/crates/ra_ide/src/snapshots/highlight_strings.html
+++ b/crates/ra_ide/src/snapshots/highlight_strings.html
@@ -25,6 +25,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .variable           { color: #DCDCCC; }
 .format_specifier   { color: #CC696B; }
 .mutable            { text-decoration: underline; }
+.unresolved_reference { color: #FC5555; }
+.escape_sequence    { color: #94BFF3; }
 .keyword            { color: #F0DFAF; font-weight: bold; }
 .keyword.unsafe     { color: #BC8383; font-weight: bold; }
@@ -82,6 +84,10 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
    <span class="macro">println!</span>(<span class="string_literal">r"Hello, </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="string_literal">"world"</span>);
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="variable">\x41</span><span class="format_specifier">}</span><span class="string_literal">"</span>, A = <span class="numeric_literal">92</span>);
+    <span class="comment">// escape sequences</span>
+    <span class="macro">println!</span>(<span class="string_literal">"Hello</span><span class="escape_sequence">\n</span><span class="string_literal">World"</span>);
+    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="escape_sequence">\u{48}</span><span class="escape_sequence">\x65</span><span class="escape_sequence">\x6C</span><span class="escape_sequence">\x6C</span><span class="escape_sequence">\x6F</span><span class="string_literal"> World"</span>);
+    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="escape_sequence">\x41</span><span class="format_specifier">}</span><span class="string_literal">"</span>, A = <span class="numeric_literal">92</span>);
    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="variable">ничоси</span><span class="format_specifier">}</span><span class="string_literal">"</span>, ничоси = <span class="numeric_literal">92</span>);
 }</code></pre>
 \ No newline at end of file
diff --git a/crates/ra_ide/src/snapshots/highlight_unsafe.html b/crates/ra_ide/src/snapshots/highlight_unsafe.html
index bd24e6e38..73438fbb4 100644
--- a/crates/ra_ide/src/snapshots/highlight_unsafe.html
+++ b/crates/ra_ide/src/snapshots/highlight_unsafe.html
@@ -25,6 +25,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .variable           { color: #DCDCCC; }
 .format_specifier   { color: #CC696B; }
 .mutable            { text-decoration: underline; }
+.unresolved_reference { color: #FC5555; }
+.escape_sequence    { color: #94BFF3; }
 .keyword            { color: #F0DFAF; font-weight: bold; }
 .keyword.unsafe     { color: #BC8383; font-weight: bold; }
diff --git a/crates/ra_ide/src/snapshots/highlighting.html b/crates/ra_ide/src/snapshots/highlighting.html
index 33548d43c..0c4f0a018 100644
--- a/crates/ra_ide/src/snapshots/highlighting.html
+++ b/crates/ra_ide/src/snapshots/highlighting.html
@@ -25,6 +25,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .variable           { color: #DCDCCC; }
 .format_specifier   { color: #CC696B; }
 .mutable            { text-decoration: underline; }
+.unresolved_reference { color: #FC5555; }
+.escape_sequence    { color: #94BFF3; }
 .keyword            { color: #F0DFAF; font-weight: bold; }
 .keyword.unsafe     { color: #BC8383; font-weight: bold; }
@@ -62,6 +64,12 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
    }
 }
+<span class="macro">macro_rules!</span> <span class="macro declaration">noop</span> {
+    ($expr:expr) =&gt; {
+        $expr
+    }
+}
 <span class="comment">// comment</span>
 <span class="keyword">fn</span> <span class="function declaration">main</span>() {
    <span class="macro">println!</span>(<span class="string_literal">"Hello, {}!"</span>, <span class="numeric_literal">92</span>);
@@ -80,6 +88,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
        <span class="comment">// Do nothing</span>
    }
+    <span class="macro">noop!</span>(<span class="macro">noop</span><span class="macro">!</span>(<span class="numeric_literal">1</span>));
    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">x</span> = <span class="numeric_literal">42</span>;
    <span class="keyword">let</span> <span class="variable declaration mutable">y</span> = &<span class="keyword">mut</span> <span class="variable mutable">x</span>;
    <span class="keyword">let</span> <span class="variable declaration">z</span> = &<span class="variable mutable">y</span>;
diff --git a/crates/ra_ide/src/snapshots/rainbow_highlighting.html b/crates/ra_ide/src/snapshots/rainbow_highlighting.html
index 1ab06182c..a74a70069 100644
--- a/crates/ra_ide/src/snapshots/rainbow_highlighting.html
+++ b/crates/ra_ide/src/snapshots/rainbow_highlighting.html
@@ -25,6 +25,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .variable           { color: #DCDCCC; }
 .format_specifier   { color: #CC696B; }
 .mutable            { text-decoration: underline; }
+.unresolved_reference { color: #FC5555; }
+.escape_sequence    { color: #94BFF3; }
 .keyword            { color: #F0DFAF; font-weight: bold; }
 .keyword.unsafe     { color: #BC8383; font-weight: bold; }
diff --git a/crates/ra_ide/src/ssr.rs b/crates/ra_ide/src/ssr.rs
index 93e9aee1d..762aab962 100644
--- a/crates/ra_ide/src/ssr.rs
+++ b/crates/ra_ide/src/ssr.rs
@@ -27,11 +27,11 @@ impl std::error::Error for SsrError {}
 //
 // Search and replace with named wildcards that will match any expression.
 // The syntax for a structural search replace command is `<search_pattern> ==>> <replace_pattern>`.
-// A `$<name>:expr` placeholder in the search pattern will match any expression and `$<name>` will reference it in the replacement.
+// A `$<name>` placeholder in the search pattern will match any AST node and `$<name>` will reference it in the replacement.
 // Available via the command `rust-analyzer.ssr`.
 //
 // ```rust
-// // Using structural search replace command [foo($a:expr, $b:expr) ==>> ($a).foo($b)]
+// // Using structural search replace command [foo($a, $b) ==>> ($a).foo($b)]
 //
 // // BEFORE
 // String::from(foo(y + 5, z))
@@ -79,7 +79,7 @@ struct SsrPattern {
    vars: Vec<Var>,
 }
-/// represents an `$var` in an SSR query
+/// Represents a `$var` in an SSR query.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 struct Var(String);
@@ -122,8 +122,7 @@ impl FromStr for SsrQuery {
        let mut pattern = it.next().expect("something").to_string();
        for part in it.map(split_by_var) {
-            let (var, var_type, remainder) = part?;
+            let (var, remainder) = part?;
-            is_expr(var_type)?;
            let new_var = create_name(var, &mut vars)?;
            pattern.push_str(new_var);
            pattern.push_str(remainder);
@@ -166,15 +165,11 @@ fn traverse(node: &SyntaxNode, go: &mut impl FnMut(&SyntaxNode) -> bool) {
    }
 }
-fn split_by_var(s: &str) -> Result<(&str, &str, &str), SsrError> {
+fn split_by_var(s: &str) -> Result<(&str, &str), SsrError> {
-    let end_of_name = s.find(':').ok_or_else(|| SsrError("Use $<name>:expr".into()))?;
+    let end_of_name = s.find(|c| !char::is_ascii_alphanumeric(&c)).unwrap_or_else(|| s.len());
-    let name = &s[0..end_of_name];
+    let name = &s[..end_of_name];
    is_name(name)?;
-    let type_begin = end_of_name + 1;
+    Ok((name, &s[end_of_name..]))
-    let type_length =
-        s[type_begin..].find(|c| !char::is_ascii_alphanumeric(&c)).unwrap_or_else(|| s.len());
-    let type_name = &s[type_begin..type_begin + type_length];
-    Ok((name, type_name, &s[type_begin + type_length..]))
 }
 fn is_name(s: &str) -> Result<(), SsrError> {
@@ -185,14 +180,6 @@ fn is_name(s: &str) -> Result<(), SsrError> {
    }
 }
-fn is_expr(s: &str) -> Result<(), SsrError> {
-    if s == "expr" {
-        Ok(())
-    } else {
-        Err(SsrError("Only $<name>:expr is supported".into()))
-    }
-}
 fn replace_in_template(template: String, var: &str, new_var: &str) -> String {
    let name = format!("${}", var);
    template.replace(&name, new_var)
@@ -450,7 +437,7 @@ mod tests {
    #[test]
    fn parser_happy_case() {
-        let result: SsrQuery = "foo($a:expr, $b:expr) ==>> bar($b, $a)".parse().unwrap();
+        let result: SsrQuery = "foo($a, $b) ==>> bar($b, $a)".parse().unwrap();
        assert_eq!(&result.pattern.pattern.text(), "foo(__search_pattern_a, __search_pattern_b)");
        assert_eq!(result.pattern.vars.len(), 2);
        assert_eq!(result.pattern.vars[0].0, "__search_pattern_a");
@@ -477,30 +464,9 @@ mod tests {
    }
    #[test]
-    fn parser_no_pattern_type() {
-        assert_eq!(parse_error_text("foo($a) ==>>"), "Parse error: Use $<name>:expr");
-    }
-    #[test]
-    fn parser_invalid_name() {
-        assert_eq!(
-            parse_error_text("foo($a+:expr) ==>>"),
-            "Parse error: Name can contain only alphanumerics and _"
-        );
-    }
-    #[test]
-    fn parser_invalid_type() {
-        assert_eq!(
-            parse_error_text("foo($a:ident) ==>>"),
-            "Parse error: Only $<name>:expr is supported"
-        );
-    }
-    #[test]
    fn parser_repeated_name() {
        assert_eq!(
-            parse_error_text("foo($a:expr, $a:expr) ==>>"),
+            parse_error_text("foo($a, $a) ==>>"),
            "Parse error: Name `a` repeats more than once"
        );
    }
@@ -517,7 +483,7 @@ mod tests {
    #[test]
    fn parse_match_replace() {
-        let query: SsrQuery = "foo($x:expr) ==>> bar($x)".parse().unwrap();
+        let query: SsrQuery = "foo($x) ==>> bar($x)".parse().unwrap();
        let input = "fn main() { foo(1+2); }";
        let code = SourceFile::parse(input).tree();
@@ -549,7 +515,7 @@ mod tests {
    #[test]
    fn ssr_function_to_method() {
        assert_ssr_transform(
-            "my_function($a:expr, $b:expr) ==>> ($a).my_method($b)",
+            "my_function($a, $b) ==>> ($a).my_method($b)",
            "loop { my_function( other_func(x, y), z + w) }",
            "loop { (other_func(x, y)).my_method(z + w) }",
        )
@@ -558,7 +524,7 @@ mod tests {
    #[test]
    fn ssr_nested_function() {
        assert_ssr_transform(
-            "foo($a:expr, $b:expr, $c:expr) ==>> bar($c, baz($a, $b))",
+            "foo($a, $b, $c) ==>> bar($c, baz($a, $b))",
            "fn main { foo  (x + value.method(b), x+y-z, true && false) }",
            "fn main { bar(true && false, baz(x + value.method(b), x+y-z)) }",
        )
@@ -567,7 +533,7 @@ mod tests {
    #[test]
    fn ssr_expected_spacing() {
        assert_ssr_transform(
-            "foo($x:expr) + bar() ==>> bar($x)",
+            "foo($x) + bar() ==>> bar($x)",
            "fn main() { foo(5) + bar() }",
            "fn main() { bar(5) }",
        );
@@ -576,7 +542,7 @@ mod tests {
    #[test]
    fn ssr_with_extra_space() {
        assert_ssr_transform(
-            "foo($x:expr  ) +    bar() ==>> bar($x)",
+            "foo($x  ) +    bar() ==>> bar($x)",
            "fn main() { foo(  5 )  +bar(   ) }",
            "fn main() { bar(5) }",
        );
@@ -585,7 +551,7 @@ mod tests {
    #[test]
    fn ssr_keeps_nested_comment() {
        assert_ssr_transform(
-            "foo($x:expr) ==>> bar($x)",
+            "foo($x) ==>> bar($x)",
            "fn main() { foo(other(5 /* using 5 */)) }",
            "fn main() { bar(other(5 /* using 5 */)) }",
        )
@@ -594,7 +560,7 @@ mod tests {
    #[test]
    fn ssr_keeps_comment() {
        assert_ssr_transform(
-            "foo($x:expr) ==>> bar($x)",
+            "foo($x) ==>> bar($x)",
            "fn main() { foo(5 /* using 5 */) }",
            "fn main() { bar(5)/* using 5 */ }",
        )
@@ -603,7 +569,7 @@ mod tests {
    #[test]
    fn ssr_struct_lit() {
        assert_ssr_transform(
-            "foo{a: $a:expr, b: $b:expr} ==>> foo::new($a, $b)",
+            "foo{a: $a, b: $b} ==>> foo::new($a, $b)",
            "fn main() { foo{b:2, a:1} }",
            "fn main() { foo::new(1, 2) }",
        )
@@ -612,7 +578,7 @@ mod tests {
    #[test]
    fn ssr_call_and_method_call() {
        assert_ssr_transform(
-            "foo::<'a>($a:expr, $b:expr)) ==>> foo2($a, $b)",
+            "foo::<'a>($a, $b)) ==>> foo2($a, $b)",
            "fn main() { get().bar.foo::<'a>(1); }",
            "fn main() { foo2(get().bar, 1); }",
        )
@@ -621,7 +587,7 @@ mod tests {
    #[test]
    fn ssr_method_call_and_call() {
        assert_ssr_transform(
-            "$o:expr.foo::<i32>($a:expr)) ==>> $o.foo2($a)",
+            "$o.foo::<i32>($a)) ==>> $o.foo2($a)",
            "fn main() { X::foo::<i32>(x, 1); }",
            "fn main() { x.foo2(1); }",
        )
diff --git a/crates/ra_ide/src/syntax_highlighting.rs b/crates/ra_ide/src/syntax_highlighting.rs
index ab45c364a..854b6cc6d 100644
--- a/crates/ra_ide/src/syntax_highlighting.rs
+++ b/crates/ra_ide/src/syntax_highlighting.rs
@@ -44,6 +44,7 @@ pub(crate) fn highlight(
    db: &RootDatabase,
    file_id: FileId,
    range_to_highlight: Option<TextRange>,
+    syntactic_name_ref_highlighting: bool,
 ) -> Vec<HighlightedRange> {
    let _p = profile("highlight");
    let sema = Semantics::new(db);
@@ -104,6 +105,7 @@ pub(crate) fn highlight(
                    if let Some((highlight, binding_hash)) = highlight_element(
                        &sema,
                        &mut bindings_shadow_count,
+                        syntactic_name_ref_highlighting,
                        name.syntax().clone().into(),
                    ) {
                        stack.add(HighlightedRange {
@@ -160,23 +162,25 @@ pub(crate) fn highlight(
            // Check if macro takes a format string and remember it for highlighting later.
            // The macros that accept a format string expand to a compiler builtin macros
            // `format_args` and `format_args_nl`.
-            if let Some(fmt_macro_call) = parent.parent().and_then(ast::MacroCall::cast) {
+            if let Some(name) = parent
-                if let Some(name) =
+                .parent()
-                    fmt_macro_call.path().and_then(|p| p.segment()).and_then(|s| s.name_ref())
+                .and_then(ast::MacroCall::cast)
-                {
+                .and_then(|mc| mc.path())
-                    match name.text().as_str() {
+                .and_then(|p| p.segment())
-                        "format_args" | "format_args_nl" => {
+                .and_then(|s| s.name_ref())
-                            format_string = parent
+            {
-                                .children_with_tokens()
+                match name.text().as_str() {
-                                .filter(|t| t.kind() != WHITESPACE)
+                    "format_args" | "format_args_nl" => {
-                                .nth(1)
+                        format_string = parent
-                                .filter(|e| {
+                            .children_with_tokens()
-                                    ast::String::can_cast(e.kind())
+                            .filter(|t| t.kind() != WHITESPACE)
-                                        || ast::RawString::can_cast(e.kind())
+                            .nth(1)
-                                })
+                            .filter(|e| {
-                        }
+                                ast::String::can_cast(e.kind())
-                        _ => {}
+                                    || ast::RawString::can_cast(e.kind())
+                            })
                    }
+                    _ => {}
                }
            }
@@ -198,15 +202,18 @@ pub(crate) fn highlight(
        let is_format_string = format_string.as_ref() == Some(&element_to_highlight);
-        if let Some((highlight, binding_hash)) =
+        if let Some((highlight, binding_hash)) = highlight_element(
-            highlight_element(&sema, &mut bindings_shadow_count, element_to_highlight.clone())
+            &sema,
-        {
+            &mut bindings_shadow_count,
+            syntactic_name_ref_highlighting,
+            element_to_highlight.clone(),
+        ) {
            stack.add(HighlightedRange { range, highlight, binding_hash });
            if let Some(string) =
                element_to_highlight.as_token().cloned().and_then(ast::String::cast)
            {
-                stack.push();
                if is_format_string {
+                    stack.push();
                    string.lex_format_specifier(|piece_range, kind| {
                        if let Some(highlight) = highlight_format_specifier(kind) {
                            stack.add(HighlightedRange {
@@ -216,13 +223,27 @@ pub(crate) fn highlight(
                            });
                        }
                    });
+                    stack.pop();
+                }
+                // Highlight escape sequences
+                if let Some(char_ranges) = string.char_ranges() {
+                    stack.push();
+                    for (piece_range, _) in char_ranges.iter().filter(|(_, char)| char.is_ok()) {
+                        if string.text()[piece_range.start().into()..].starts_with('\\') {
+                            stack.add(HighlightedRange {
+                                range: piece_range + range.start(),
+                                highlight: HighlightTag::EscapeSequence.into(),
+                                binding_hash: None,
+                            });
+                        }
+                    }
+                    stack.pop_and_inject(false);
                }
-                stack.pop();
            } else if let Some(string) =
                element_to_highlight.as_token().cloned().and_then(ast::RawString::cast)
            {
-                stack.push();
                if is_format_string {
+                    stack.push();
                    string.lex_format_specifier(|piece_range, kind| {
                        if let Some(highlight) = highlight_format_specifier(kind) {
                            stack.add(HighlightedRange {
@@ -232,8 +253,8 @@ pub(crate) fn highlight(
                            });
                        }
                    });
+                    stack.pop();
                }
-                stack.pop();
            }
        }
    }
@@ -408,6 +429,7 @@ fn macro_call_range(macro_call: &ast::MacroCall) -> Option<TextRange> {
 fn highlight_element(
    sema: &Semantics<RootDatabase>,
    bindings_shadow_count: &mut FxHashMap<Name, u32>,
+    syntactic_name_ref_highlighting: bool,
    element: SyntaxElement,
 ) -> Option<(Highlight, Option<u64>)> {
    let db = sema.db;
@@ -461,6 +483,7 @@ fn highlight_element(
                    }
                    NameRefClass::FieldShorthand { .. } => HighlightTag::Field.into(),
                },
+                None if syntactic_name_ref_highlighting => highlight_name_ref_by_syntax(name_ref),
                None => HighlightTag::UnresolvedReference.into(),
            }
        }
@@ -493,6 +516,9 @@ fn highlight_element(
            h |= HighlightModifier::Unsafe;
            h
        }
+        T![!] if element.parent().and_then(ast::MacroCall::cast).is_some() => {
+            Highlight::new(HighlightTag::Macro)
+        }
        k if k.is_keyword() => {
            let h = Highlight::new(HighlightTag::Keyword);
@@ -609,3 +635,53 @@ fn highlight_name_by_syntax(name: ast::Name) -> Highlight {
    tag.into()
 }
+fn highlight_name_ref_by_syntax(name: ast::NameRef) -> Highlight {
+    let default = HighlightTag::UnresolvedReference;
+    let parent = match name.syntax().parent() {
+        Some(it) => it,
+        _ => return default.into(),
+    };
+    let tag = match parent.kind() {
+        METHOD_CALL_EXPR => HighlightTag::Function,
+        FIELD_EXPR => HighlightTag::Field,
+        PATH_SEGMENT => {
+            let path = match parent.parent().and_then(ast::Path::cast) {
+                Some(it) => it,
+                _ => return default.into(),
+            };
+            let expr = match path.syntax().parent().and_then(ast::PathExpr::cast) {
+                Some(it) => it,
+                _ => {
+                    // within path, decide whether it is module or adt by checking for uppercase name
+                    return if name.text().chars().next().unwrap_or_default().is_uppercase() {
+                        HighlightTag::Struct
+                    } else {
+                        HighlightTag::Module
+                    }
+                    .into();
+                }
+            };
+            let parent = match expr.syntax().parent() {
+                Some(it) => it,
+                None => return default.into(),
+            };
+            match parent.kind() {
+                CALL_EXPR => HighlightTag::Function,
+                _ => {
+                    if name.text().chars().next().unwrap_or_default().is_uppercase() {
+                        HighlightTag::Struct
+                    } else {
+                        HighlightTag::Constant
+                    }
+                }
+            }
+        }
+        _ => default,
+    };
+    tag.into()
+}
diff --git a/crates/ra_ide/src/syntax_highlighting/html.rs b/crates/ra_ide/src/syntax_highlighting/html.rs
index 5bada6252..99b6b25ab 100644
--- a/crates/ra_ide/src/syntax_highlighting/html.rs
+++ b/crates/ra_ide/src/syntax_highlighting/html.rs
@@ -19,7 +19,7 @@ pub(crate) fn highlight_as_html(db: &RootDatabase, file_id: FileId, rainbow: boo
        )
    }
-    let ranges = highlight(db, file_id, None);
+    let ranges = highlight(db, file_id, None, false);
    let text = parse.tree().syntax().to_string();
    let mut prev_pos = TextSize::from(0);
    let mut buf = String::new();
@@ -84,6 +84,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .variable           { color: #DCDCCC; }
 .format_specifier   { color: #CC696B; }
 .mutable            { text-decoration: underline; }
+.unresolved_reference { color: #FC5555; }
+.escape_sequence    { color: #94BFF3; }
 .keyword            { color: #F0DFAF; font-weight: bold; }
 .keyword.unsafe     { color: #BC8383; font-weight: bold; }
diff --git a/crates/ra_ide/src/syntax_highlighting/injection.rs b/crates/ra_ide/src/syntax_highlighting/injection.rs
index 3575a0fc6..929a5cc5c 100644
--- a/crates/ra_ide/src/syntax_highlighting/injection.rs
+++ b/crates/ra_ide/src/syntax_highlighting/injection.rs
@@ -53,6 +53,10 @@ pub(super) fn highlight_injection(
 /// Mapping from extracted documentation code to original code
 type RangesMap = BTreeMap<TextSize, TextSize>;
+const RUSTDOC_FENCE: &'static str = "```";
+const RUSTDOC_FENCE_TOKENS: &[&'static str] =
+    &["", "rust", "should_panic", "ignore", "no_run", "compile_fail", "edition2015", "edition2018"];
 /// Extracts Rust code from documentation comments as well as a mapping from
 /// the extracted source code back to the original source ranges.
 /// Lastly, a vector of new comment highlight ranges (spanning only the
@@ -67,6 +71,7 @@ pub(super) fn extract_doc_comments(
    // Mapping from extracted documentation code to original code
    let mut range_mapping: RangesMap = BTreeMap::new();
    let mut line_start = TextSize::try_from(prefix.len()).unwrap();
+    let mut is_codeblock = false;
    let mut is_doctest = false;
    // Replace the original, line-spanning comment ranges by new, only comment-prefix
    // spanning comment ranges.
@@ -76,8 +81,13 @@ pub(super) fn extract_doc_comments(
        .filter_map(|el| el.into_token().and_then(ast::Comment::cast))
        .filter(|comment| comment.kind().doc.is_some())
        .filter(|comment| {
-            if comment.text().contains("```") {
+            if let Some(idx) = comment.text().find(RUSTDOC_FENCE) {
-                is_doctest = !is_doctest;
+                is_codeblock = !is_codeblock;
+                // Check whether code is rust by inspecting fence guards
+                let guards = &comment.text()[idx + RUSTDOC_FENCE.len()..];
+                let is_rust =
+                    guards.split(',').all(|sub| RUSTDOC_FENCE_TOKENS.contains(&sub.trim()));
+                is_doctest = is_codeblock && is_rust;
                false
            } else {
                is_doctest
@@ -137,7 +147,7 @@ pub(super) fn highlight_doc_comment(
    let (analysis, tmp_file_id) = Analysis::from_single_file(text);
    stack.push();
-    for mut h in analysis.highlight(tmp_file_id).unwrap() {
+    for mut h in analysis.with_db(|db| super::highlight(db, tmp_file_id, None, true)).unwrap() {
        // Determine start offset and end offset in case of multi-line ranges
        let mut start_offset = None;
        let mut end_offset = None;
diff --git a/crates/ra_ide/src/syntax_highlighting/tags.rs b/crates/ra_ide/src/syntax_highlighting/tags.rs
index 94f466966..400d22fb6 100644
--- a/crates/ra_ide/src/syntax_highlighting/tags.rs
+++ b/crates/ra_ide/src/syntax_highlighting/tags.rs
@@ -23,6 +23,7 @@ pub enum HighlightTag {
    Constant,
    Enum,
    EnumVariant,
+    EscapeSequence,
    Field,
    FormatSpecifier,
    Function,
@@ -71,6 +72,7 @@ impl HighlightTag {
            HighlightTag::Constant => "constant",
            HighlightTag::Enum => "enum",
            HighlightTag::EnumVariant => "enum_variant",
+            HighlightTag::EscapeSequence => "escape_sequence",
            HighlightTag::Field => "field",
            HighlightTag::FormatSpecifier => "format_specifier",
            HighlightTag::Function => "function",
diff --git a/crates/ra_ide/src/syntax_highlighting/tests.rs b/crates/ra_ide/src/syntax_highlighting/tests.rs
index 949bf59a0..b4d56a7a0 100644
--- a/crates/ra_ide/src/syntax_highlighting/tests.rs
+++ b/crates/ra_ide/src/syntax_highlighting/tests.rs
@@ -43,6 +43,12 @@ def_fn! {
    }
 }
+macro_rules! noop {
+    ($expr:expr) => {
+        $expr
+    }
+}
 // comment
 fn main() {
    println!("Hello, {}!", 92);
@@ -61,6 +67,8 @@ fn main() {
        // Do nothing
    }
+    noop!(noop!(1));
    let mut x = 42;
    let y = &mut x;
    let z = &y;
@@ -238,6 +246,10 @@ fn main() {
    println!(r"Hello, {}!", "world");
+    // escape sequences
+    println!("Hello\nWorld");
+    println!("\u{48}\x65\x6C\x6C\x6F World");
    println!("{\x41}", A = 92);
    println!("{ничоси}", ничоси = 92);
 }"#
@@ -279,7 +291,13 @@ fn main() {
 fn test_highlight_doctest() {
    check_highlighting(
        r#"
+struct Foo {
+    bar: bool,
+}
 impl Foo {
+    pub const bar: bool = true;
    /// Constructs a new `Foo`.
    ///
    /// # Examples
@@ -289,7 +307,7 @@ impl Foo {
    /// let mut foo: Foo = Foo::new();
    /// ```
    pub const fn new() -> Foo {
-        Foo { }
+        Foo { bar: true }
    }
    /// `bar` method on `Foo`.
@@ -297,11 +315,15 @@ impl Foo {
    /// # Examples
    ///
    /// ```
+    /// use x::y;
+    ///
    /// let foo = Foo::new();
    ///
    /// // calls bar on foo
    /// assert!(foo.bar());
    ///
+    /// let bar = foo.bar || Foo::bar;
+    ///
    /// /* multi-line
    ///        comment */
    ///
@@ -311,9 +333,13 @@ impl Foo {
    ///
    /// ```
    ///
-    /// ```
+    /// ```rust,no_run
    /// let foobar = Foo::new().bar();
    /// ```
+    ///
+    /// ```sh
+    /// echo 1
+    /// ```
    pub fn foo(&self) -> bool {
        true
    }
@@ -322,7 +348,7 @@ impl Foo {
        .trim(),
        "crates/ra_ide/src/snapshots/highlight_doctest.html",
        false,
-    )
+    );
 }
 /// Highlights the code given by the `ra_fixture` argument, renders the